Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
acp_thread: Share v2 compaction updates (#65254)
Ben Brandt391447731256
diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rsindex 414d824da5c..7969ccdd8d0 100644--- a/crates/acp_thread/src/acp_thread.rs+++ b/crates/acp_thread/src/acp_thread.rs@@ -1,5 +1,6 @@pub mod auth_methods;pub mod commands;+pub mod compaction;pub mod config_options;mod connection;pub mod content;@@ -849,14 +850,14 @@ pub enum ContextCompactionStatus {Other(Arc<str>),}-impl From<acp_v1::CompactionStatus> for ContextCompactionStatus {- fn from(status: acp_v1::CompactionStatus) -> Self {+impl From<acp_v2::CompactionStatus> for ContextCompactionStatus {+ fn from(status: acp_v2::CompactionStatus) -> Self {match status {- acp_v1::CompactionStatus::InProgress => Self::InProgress,- acp_v1::CompactionStatus::Completed => Self::Completed,- acp_v1::CompactionStatus::Failed => Self::Failed,- acp_v1::CompactionStatus::Cancelled => Self::Canceled,- acp_v1::CompactionStatus::Other(status) => Self::Other(status.into()),+ acp_v2::CompactionStatus::InProgress => Self::InProgress,+ acp_v2::CompactionStatus::Completed => Self::Completed,+ acp_v2::CompactionStatus::Failed => Self::Failed,+ acp_v2::CompactionStatus::Cancelled => Self::Canceled,+ acp_v2::CompactionStatus::Other(status) => Self::Other(status.into()),_ => Self::Other("unknown".into()),}}@@ -870,7 +871,8 @@ pub struct ContextCompaction {pub id: ContextCompactionId,pub status: ContextCompactionStatus,pub error: Option<Entity<Markdown>>,- pub summary: Vec<ContentBlock>,+ pub summary: MessageContent,+ pub meta: Option<acp_v2::Meta>,}impl ContextCompaction {@@ -880,26 +882,16 @@ impl ContextCompaction {fn apply_update(&mut self,- update: acp_v1::CompactionUpdate,+ update: acp_v2::CompactionUpdate,language_registry: &Arc<LanguageRegistry>,cx: &mut App,- ) -> Result<()> {- let summary = match update.summary {- MaybeUndefined::Undefined => MaybeUndefined::Undefined,- MaybeUndefined::Null => MaybeUndefined::Null,- MaybeUndefined::Value(blocks) => MaybeUndefined::Value(- blocks- .into_iter()- .map(content::from_v1)- .collect::<Result<Vec<_>>>()?,- ),- };+ ) {self.status = update.status.into();- match summary {+ match update.summary {MaybeUndefined::Undefined => {}- MaybeUndefined::Null => self.summary.clear(),+ MaybeUndefined::Null => self.summary = MessageContent::default(),MaybeUndefined::Value(blocks) => {- self.summary.clear();+ self.summary = MessageContent::default();for block in blocks {self.append_summary(block, language_registry, cx);}@@ -916,7 +908,11 @@ impl ContextCompaction {}}}- Ok(())+ match update.meta {+ MaybeUndefined::Undefined => {}+ MaybeUndefined::Null => self.meta = None,+ MaybeUndefined::Value(meta) => self.meta = Some(meta),+ }}fn append_summary(@@ -925,14 +921,8 @@ impl ContextCompaction {language_registry: &Arc<LanguageRegistry>,cx: &mut App,) {- if let acp_v2::ContentBlock::Text(text) = &content- && let Some(markdown) = self.summary.last().and_then(ContentBlock::plain_markdown)- {- markdown.update(cx, |markdown, cx| markdown.append(&text.text, cx));- } else {- self.summary- .push(ContentBlock::new_output(content, language_registry, cx));- }+ self.summary+ .append_compaction_summary(content, language_registry, cx);}}@@ -970,7 +960,7 @@ impl AgentThreadEntry {};let mut markdown =format!("## Context Compaction ({})\n\n", MarkdownEscaped(status));- for block in &compaction.summary {+ for block in compaction.summary.blocks() {markdown.push_str(block.to_markdown(cx));markdown.push_str("\n\n");}@@ -2033,6 +2023,38 @@ impl MessageContent {self.source_version = MessageContentVersion::next();}+ fn append_compaction_summary(+ &mut self,+ block: acp_v2::ContentBlock,+ language_registry: &Arc<LanguageRegistry>,+ cx: &mut App,+ ) {+ // Compaction links remain separate blocks rather than joining streamed message text.+ if let acp_v2::ContentBlock::Text(text) = &block {+ if let Some(markdown) = self.trailing_text() {+ markdown.update(cx, |markdown, cx| markdown.append(&text.text, cx));+ } else {+ self.blocks.push(RenderedMessageBlock {+ render: RenderBlock::Markdown {+ markdown: ContentBlock::create_markdown(+ text.text.clone(),+ language_registry,+ cx,+ ),+ },+ source_index: None,+ });+ }+ } else {+ self.blocks.push(RenderedMessageBlock {+ render: ContentBlock::render_from_source(&block, language_registry, cx),+ source_index: Some(self.source_blocks.len()),+ });+ }+ self.source_blocks.push(block);+ self.source_version = MessageContentVersion::next();+ }+fn append_rendered(&mut self,block: &acp_v2::ContentBlock,@@ -2333,6 +2355,7 @@ impl ContentBlock {}}+ #[cfg(test)]fn plain_markdown(&self) -> Option<&Entity<Markdown>> {match &self.render {RenderBlock::Markdown { markdown } => Some(markdown),@@ -4324,12 +4347,16 @@ impl AcpThread {self.update_tool_call(tool_call_update, cx)?;}acp_v1::SessionUpdate::CompactionUpdate(compaction_update) => {- self.upsert_context_compaction_update(compaction_update, cx)- .map_err(acp_v1::Error::from)?;+ self.upsert_context_compaction_update(+ compaction::update_from_v1(compaction_update).map_err(acp_v1::Error::from)?,+ cx,+ );}acp_v1::SessionUpdate::CompactionSummaryChunk(summary_chunk) => {- self.append_context_compaction_summary(summary_chunk, cx)- .map_err(acp_v1::Error::from)?;+ self.append_context_compaction_summary(+ compaction::chunk_from_v1(summary_chunk).map_err(acp_v1::Error::from)?,+ cx,+ );}acp_v1::SessionUpdate::Plan(plan) => {self.update_plan(plan, cx).map_err(acp_v1::Error::from)?;@@ -5055,11 +5082,11 @@ impl AcpThread {}}- fn upsert_context_compaction_update(+ pub fn upsert_context_compaction_update(&mut self,- update: acp_v1::CompactionUpdate,+ update: acp_v2::CompactionUpdate,cx: &mut Context<Self>,- ) -> Result<()> {+ ) {let id = ContextCompactionId(update.compaction_id.0.clone());let language_registry = self.project.read(cx).languages().clone();@@ -5075,27 +5102,27 @@ impl AcpThread {_ => None,}){- compaction.apply_update(update, &language_registry, cx)?;+ compaction.apply_update(update, &language_registry, cx);cx.emit(AcpThreadEvent::EntryUpdated(entry_index));- return Ok(());+ return;}let mut compaction = ContextCompaction {id,status: update.status.clone().into(),error: None,- summary: Vec::new(),+ summary: MessageContent::default(),+ meta: None,};- compaction.apply_update(update, &language_registry, cx)?;+ compaction.apply_update(update, &language_registry, cx);self.push_entry(AgentThreadEntry::ContextCompaction(compaction), cx);- Ok(())}- fn append_context_compaction_summary(+ pub fn append_context_compaction_summary(&mut self,- chunk: acp_v1::CompactionSummaryChunk,+ chunk: acp_v2::CompactionSummaryChunk,cx: &mut Context<Self>,- ) -> Result<()> {+ ) {let language_registry = self.project.read(cx).languages().clone();if let Some((entry_index, compaction)) =self.entries@@ -5112,10 +5139,10 @@ impl AcpThread {_ => None,}){- compaction.append_summary(content::from_v1(chunk.content)?, &language_registry, cx);+ // Chunk metadata is delivery-scoped, not a patch to the compaction record.+ compaction.append_summary(chunk.content, &language_registry, cx);cx.emit(AcpThreadEvent::EntryUpdated(entry_index));}- Ok(())}pub fn update_context_compaction(@@ -12143,7 +12170,8 @@ mod tests {id: ContextCompactionId("c1".into()),status: ContextCompactionStatus::Completed,error: None,- summary: Vec::new(),+ summary: MessageContent::default(),+ meta: None,},cx,);@@ -12639,7 +12667,8 @@ mod tests {assert_eq!(compaction.summary- .first()+ .blocks()+ .next().map(|block| block.to_markdown(cx)),Some(summary));@@ -12667,7 +12696,7 @@ mod tests {panic!("compaction entry must still exist");};assert_eq!(compaction.status, ContextCompactionStatus::Failed);- assert!(compaction.summary.is_empty());+ assert_eq!(compaction.summary.blocks().len(), 0);assert_eq!(compaction.error@@ -12743,7 +12772,7 @@ mod tests {else {panic!("compaction entry must still exist");};- assert_eq!(compaction.summary.len(), expected_length);+ assert_eq!(compaction.summary.blocks().len(), expected_length);}});}@@ -12772,10 +12801,22 @@ mod tests {));let audio = acp_v1::ContentBlock::Audio(acp_v1::AudioContent::new("YXVkaW8=", "audio/wav"));let blocks = vec![- acp_v1::ContentBlock::Text(acp_v1::TextContent::new("retained ")),- acp_v1::ContentBlock::Text(acp_v1::TextContent::new("context")),+ acp_v1::ContentBlock::Text(acp_v1::TextContent::new("retained ").meta(+ acp_v1::Meta::from_iter([(+ "text".into(),+ serde_json::json!({"part": 1, "nested": [null, true]}),+ )]),+ )),+ acp_v1::ContentBlock::Text(acp_v1::TextContent::new("context").meta(+ acp_v1::Meta::from_iter([("text".into(), serde_json::json!({"part": 2}))]),+ )),acp_v1::ContentBlock::Resource(text_resource),- acp_v1::ContentBlock::Image(acp_v1::ImageContent::new(image_data, "image/png")),+ acp_v1::ContentBlock::Image(acp_v1::ImageContent::new(image_data, "image/png").meta(+ acp_v1::Meta::from_iter([(+ "image".into(),+ serde_json::json!({"nested": [1, {"value": "retained"}]}),+ )]),+ )),acp_v1::ContentBlock::ResourceLink(acp_v1::ResourceLink::new("Reference","https://example.com/context",@@ -12842,17 +12883,14 @@ mod tests {else {panic!("expected compaction entry");};- let [text, resource, image, link, unsupported, blob] =- compaction.summary.as_slice()- else {+ assert_eq!(compaction.summary.source_blocks(), source_blocks);+ let rendered = compaction.summary.blocks().collect::<Vec<_>>();+ let [text, resource, image, link, unsupported, blob] = rendered.as_slice() else {panic!("expected six retained content blocks");};assert_eq!(text.to_markdown(cx), "retained context");assert_eq!(- resource- .as_view()- .embedded_resource()- .map(|(resource, _)| resource),+ resource.embedded_resource().map(|(resource, _)| resource),Some(text_resource));assert_eq!(resource.to_markdown(cx), "Retained resource text");@@ -12864,7 +12902,7 @@ mod tests {Some((1, 1)));assert_eq!(- link.as_view().resource_link().map(|link| link.uri.as_str()),+ link.resource_link().map(|link| link.uri.as_str()),Some("https://example.com/context"));let Some(content) = unsupported.unsupported_content() else {@@ -12873,9 +12911,7 @@ mod tests {assert_eq!(content, stored_audio);assert!(unsupported.visible_content(cx));assert_eq!(- blob.as_view()- .embedded_resource()- .map(|(resource, _)| resource),+ blob.embedded_resource().map(|(resource, _)| resource),Some(blob_resource));assert!(blob.visible_content(cx));@@ -12913,8 +12949,13 @@ mod tests {else {panic!("expected compaction entry");};+ assert_eq!(+ compaction.summary.source_blocks(),+ std::slice::from_ref(stored_audio)+ );+ let rendered = compaction.summary.blocks().collect::<Vec<_>>();assert!(matches!(- compaction.summary.as_slice(),+ rendered.as_slice(),[block] if block.unsupported_content() == Some(stored_audio)));assert!(@@ -12950,10 +12991,10 @@ mod tests {thread.update(cx, |thread, cx| {for update in [- acp_v1::SessionUpdate::CompactionUpdate(acp_v1::CompactionUpdate::new(- "first",- acp_v1::CompactionStatus::InProgress,- )),+ acp_v1::SessionUpdate::CompactionUpdate(+ acp_v1::CompactionUpdate::new("first", acp_v1::CompactionStatus::InProgress)+ .meta(acp_v1::Meta::from_iter([("original".into(), true.into())])),+ ),acp_v1::SessionUpdate::ToolCall(acp_v1::ToolCall::new("tool", "Unrelated tool")),acp_v1::SessionUpdate::CompactionUpdate(acp_v1::CompactionUpdate::new("second",@@ -12963,10 +13004,13 @@ mod tests {"second",acp_v1::CompactionStatus::Completed,)),- acp_v1::SessionUpdate::CompactionSummaryChunk(acp_v1::CompactionSummaryChunk::new(- "first",- acp_v1::ContentBlock::Text(acp_v1::TextContent::new("partial summary")),- )),+ acp_v1::SessionUpdate::CompactionSummaryChunk(+ acp_v1::CompactionSummaryChunk::new(+ "first",+ acp_v1::ContentBlock::Text(acp_v1::TextContent::new("partial summary")),+ )+ .meta(acp_v1::Meta::from_iter([("delivery".into(), true.into())])),+ ),] {thread.handle_session_update(update, cx)@@ -13003,6 +13047,10 @@ mod tests {};assert_eq!(first.id.0.as_ref(), "first");assert_eq!(first.status, ContextCompactionStatus::Canceled);+ assert_eq!(+ first.meta,+ Some(acp_v2::Meta::from_iter([("original".into(), true.into())]))+ );assert_eq!(second.id.0.as_ref(), "second");assert_eq!(second.status, ContextCompactionStatus::Completed);assert!(@@ -13011,6 +13059,109 @@ mod tests {.starts_with("## Context Compaction (Canceled)\n\npartial summary\n\n"));});++ let source = vec![+ acp_v2::ContentBlock::Text(acp_v2::TextContent::new("replacement ").meta(+ acp_v2::Meta::from_iter([(+ "content".into(),+ serde_json::json!({"nested": [null, true]}),+ )]),+ )),+ acp_v2::ContentBlock::Other(acp_v2::OtherContentBlock::new(+ "_future_summary",+ std::collections::BTreeMap::from([(+ "payload".into(),+ serde_json::json!({"nested": [1, {"value": "retained"}]}),+ )]),+ )),+ ];+ let metadata = acp_v2::Meta::from_iter([(+ "compaction".into(),+ serde_json::json!({"nested": [1, "retained"]}),+ )]);+ thread.update(cx, |thread, cx| {+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new("first", acp_v2::CompactionStatus::Completed)+ .summary(source.clone())+ .meta(metadata.clone()),+ cx,+ );+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new(+ "first",+ acp_v2::CompactionStatus::Other("_future".into()),+ ),+ cx,+ );+ thread.append_context_compaction_summary(+ acp_v2::CompactionSummaryChunk::new("first", "ignored late text".into())+ .meta(acp_v2::Meta::from_iter([("delivery".into(), true.into())])),+ cx,+ );+ let Some(AgentThreadEntry::ContextCompaction(first)) = thread.entries.first() else {+ panic!("the original timeline position must remain");+ };+ assert_eq!(+ first.status,+ ContextCompactionStatus::Other("_future".into())+ );+ assert_eq!(first.summary.source_blocks(), source);+ assert_eq!(first.meta.as_ref(), Some(&metadata));+ assert!(!thread.is_compacting());+ });+ assert_eq!(+ *events.borrow(),+ [+ None,+ None,+ None,+ Some(2),+ Some(0),+ Some(0),+ Some(0),+ Some(0)+ ]+ );+ thread.update(cx, |thread, cx| {+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new("first", acp_v2::CompactionStatus::Failed)+ .error("failure detail")+ .meta(acp_v2::Meta::new()),+ cx,+ );+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new("first", acp_v2::CompactionStatus::Failed),+ cx,+ );+ let Some(AgentThreadEntry::ContextCompaction(first)) = thread.entries.first() else {+ panic!("the original compaction must remain");+ };+ assert_eq!(first.summary.source_blocks(), source);+ assert_eq!(first.meta, Some(acp_v2::Meta::new()));+ assert_eq!(+ first+ .error+ .as_ref()+ .expect("failure detail")+ .read(cx)+ .source(),+ "failure detail"+ );+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new("first", acp_v2::CompactionStatus::Failed)+ .summary(MaybeUndefined::Null)+ .error(MaybeUndefined::Null)+ .meta(MaybeUndefined::Null),+ cx,+ );+ let Some(AgentThreadEntry::ContextCompaction(first)) = thread.entries.first() else {+ panic!("clearing details must not remove the compaction");+ };+ assert!(first.summary.source_blocks().is_empty());+ assert_eq!(first.summary.blocks().len(), 0);+ assert!(first.error.is_none());+ assert!(first.meta.is_none());+ });}#[test]@@ -14274,12 +14425,12 @@ mod tests {#[gpui::test]fn test_context_compaction_exports_status(cx: &mut App) {for (status, expected_label) in [- (acp_v1::CompactionStatus::InProgress, "In Progress"),- (acp_v1::CompactionStatus::Completed, "Completed"),- (acp_v1::CompactionStatus::Failed, "Failed"),- (acp_v1::CompactionStatus::Cancelled, "Canceled"),+ (acp_v2::CompactionStatus::InProgress, "In Progress"),+ (acp_v2::CompactionStatus::Completed, "Completed"),+ (acp_v2::CompactionStatus::Failed, "Failed"),+ (acp_v2::CompactionStatus::Cancelled, "Canceled"),(- acp_v1::CompactionStatus::Other("interrupted".into()),+ acp_v2::CompactionStatus::Other("interrupted".into()),"interrupted",),] {@@ -14287,7 +14438,8 @@ mod tests {id: ContextCompactionId("compaction".into()),status: status.into(),error: None,- summary: Vec::new(),+ summary: MessageContent::default(),+ meta: None,});assert_eq!(entry.to_markdown(cx),@@ -18253,7 +18405,8 @@ mod tests {id: compaction_id,status: ContextCompactionStatus::InProgress,error: None,- summary: Vec::new(),+ summary: MessageContent::default(),+ meta: None,},cx,);@@ -18902,7 +19055,8 @@ mod tests {id: ContextCompactionId("compaction-1".into()),status: ContextCompactionStatus::InProgress,error: None,- summary: Vec::new(),+ summary: MessageContent::default(),+ meta: None,},cx,);diff --git a/crates/acp_thread/src/compaction.rs b/crates/acp_thread/src/compaction.rsnew file mode 100644index 00000000000..0b80b061537--- /dev/null+++ b/crates/acp_thread/src/compaction.rs@@ -0,0 +1,131 @@+use agent_client_protocol::schema::{MaybeUndefined, v1 as acp_v1, v2 as acp_v2};+use anyhow::{Result, bail};++pub fn update_from_v1(update: acp_v1::CompactionUpdate) -> Result<acp_v2::CompactionUpdate> {+ let status = match update.status {+ acp_v1::CompactionStatus::InProgress => acp_v2::CompactionStatus::InProgress,+ acp_v1::CompactionStatus::Completed => acp_v2::CompactionStatus::Completed,+ acp_v1::CompactionStatus::Failed => acp_v2::CompactionStatus::Failed,+ acp_v1::CompactionStatus::Cancelled => acp_v2::CompactionStatus::Cancelled,+ acp_v1::CompactionStatus::Other(status) => acp_v2::CompactionStatus::Other(status),+ _ => bail!("unsupported v1 compaction status variant"),+ };+ let summary = match update.summary {+ MaybeUndefined::Undefined => MaybeUndefined::Undefined,+ MaybeUndefined::Null => MaybeUndefined::Null,+ MaybeUndefined::Value(blocks) => MaybeUndefined::Value(+ blocks+ .into_iter()+ .map(crate::content::from_v1)+ .collect::<Result<Vec<_>>>()?,+ ),+ };+ Ok(+ acp_v2::CompactionUpdate::new(acp_v2::CompactionId::new(update.compaction_id.0), status)+ .summary(summary)+ .error(update.error)+ .meta(update.meta),+ )+}++pub fn chunk_from_v1(+ chunk: acp_v1::CompactionSummaryChunk,+) -> Result<acp_v2::CompactionSummaryChunk> {+ Ok(acp_v2::CompactionSummaryChunk::new(+ acp_v2::CompactionId::new(chunk.compaction_id.0),+ crate::content::from_v1(chunk.content)?,+ )+ .meta(chunk.meta))+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;+ use std::sync::Arc;++ #[test]+ fn legacy_compaction_preserves_statuses_patches_and_metadata_scopes() -> Result<()> {+ let opaque_id = " compaction/\0e\u{301}雪 ";+ let content = json!({+ "type": "resource",+ "resource": {+ "uri": "file:///summary/\0雪",+ "text": "retained \0 summary",+ "mimeType": "not/a valid mime ; 😀",+ "_meta": {"resource": {"nested": [null, "", {}]}}+ },+ "annotations": {+ "audience": ["assistant", "user"],+ "lastModified": "not a date",+ "priority": -0.25,+ "_meta": {"annotation": {"nested": [false, 0]}}+ },+ "_meta": {"content": {"nested": [null, [], true]}}+ });+ for (wire, status) in [+ (+ json!({"compactionId": opaque_id, "status": "in_progress"}),+ acp_v2::CompactionStatus::InProgress,+ ),+ (+ json!({+ "compactionId": opaque_id, "status": "completed",+ "summary": null, "error": null, "_meta": null+ }),+ acp_v2::CompactionStatus::Completed,+ ),+ (+ json!({+ "compactionId": opaque_id, "status": "failed",+ "summary": [], "error": "", "_meta": {}+ }),+ acp_v2::CompactionStatus::Failed,+ ),+ (+ json!({+ "compactionId": opaque_id, "status": "cancelled",+ "summary": [content], "error": "retained \0 error",+ "_meta": {"compaction": {"nested": [null, {}, "雪"]}}+ }),+ acp_v2::CompactionStatus::Cancelled,+ ),+ (+ json!({"compactionId": opaque_id, "status": "_custom \0 雪"}),+ acp_v2::CompactionStatus::Other("_custom \0 雪".into()),+ ),+ (+ json!({"compactionId": opaque_id, "status": "future_status"}),+ acp_v2::CompactionStatus::Other("future_status".into()),+ ),+ ] {+ let update: acp_v1::CompactionUpdate = serde_json::from_value(wire.clone())?;+ let original_id = update.compaction_id.0.clone();+ let converted = update_from_v1(update)?;+ assert!(Arc::ptr_eq(&converted.compaction_id.0, &original_id));+ assert_eq!(converted.status, status);+ assert_eq!(serde_json::to_value(converted)?, wire);+ }++ for meta in [+ None,+ Some(acp_v1::Meta::new()),+ Some(acp_v1::Meta::from_iter([(+ "delivery".into(),+ json!({"nested": [null, false, {"sequence": 0}]}),+ )])),+ ] {+ let original_id: Arc<str> = opaque_id.into();+ let chunk = acp_v1::CompactionSummaryChunk::new(+ acp_v1::CompactionId::new(original_id.clone()),+ serde_json::from_value(content.clone())?,+ )+ .meta(meta.clone());+ let converted = chunk_from_v1(chunk)?;+ assert!(Arc::ptr_eq(&converted.compaction_id.0, &original_id));+ assert_eq!(converted.meta, meta);+ assert_eq!(serde_json::to_value(converted.content)?, content);+ }+ Ok(())+ }+}diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rsindex fa332a4f144..3a50a19a24e 100644--- a/crates/agent/src/agent.rs+++ b/crates/agent/src/agent.rs@@ -4335,7 +4335,9 @@ mod internal_tests {};assert!(thread.is_compacting());assert!(compaction.is_in_progress());- assert!(compaction.summary.is_empty());+ assert_eq!(compaction.summary.blocks().len(), 0);+ assert!(compaction.summary.source_blocks().is_empty());+ assert!(compaction.meta.is_none());compaction.id.clone()});@@ -4349,7 +4351,14 @@ mod internal_tests {};assert_eq!(compaction.id, compaction_id);assert!(compaction.is_in_progress());- let [summary] = compaction.summary.as_slice() else {+ assert_eq!(+ compaction.summary.source_blocks(),+ &[acp_v2::ContentBlock::Text(acp_v2::TextContent::new(+ "retained "+ ))]+ );+ let blocks = compaction.summary.blocks().collect::<Vec<_>>();+ let [summary] = blocks.as_slice() else {panic!("native text chunks should create one retained Markdown block");};let markdown = summary@@ -4377,13 +4386,14 @@ mod internal_tests {acp_thread::ContextCompactionStatus::Completed);assert!(compaction.error.is_none());- assert_eq!(compaction.summary.len(), 1);+ assert_eq!(compaction.summary.blocks().len(), 1);+ assert_eq!(compaction.summary.markdowns().next(), Some(&summary));assert_eq!(- compaction- .summary- .first()- .and_then(|block| block.markdown()),- Some(&summary)+ compaction.summary.source_blocks(),+ &[+ acp_v2::ContentBlock::Text(acp_v2::TextContent::new("retained ")),+ acp_v2::ContentBlock::Text(acp_v2::TextContent::new("context")),+ ]);assert_eq!(summary.read(cx).source().as_ref(), "retained context");});@@ -4429,10 +4439,17 @@ mod internal_tests {assert_eq!(compaction.summary- .first()+ .blocks()+ .next().map(|block| block.to_markdown(cx)),Some("retained context"));+ assert_eq!(+ compaction.summary.source_blocks(),+ &[acp_v2::ContentBlock::Text(acp_v2::TextContent::new(+ "retained context"+ ))]+ );});}@@ -4486,7 +4503,9 @@ mod internal_tests {compaction.status,acp_thread::ContextCompactionStatus::Completed);- assert!(compaction.summary.is_empty());+ assert_eq!(compaction.summary.blocks().len(), 0);+ assert!(compaction.summary.source_blocks().is_empty());+ assert!(compaction.meta.is_none());assert!(compaction.error.is_none());assert!(!thread.is_compacting());});@@ -4752,7 +4771,11 @@ mod internal_tests {);assert!(!thread.is_compacting(), "{scenario}");assert_eq!(- compaction.summary.first().map(|block| block.to_markdown(cx)),+ compaction+ .summary+ .blocks()+ .next()+ .map(|block| block.to_markdown(cx)),partial_summary,"{scenario}");diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex b05cea6a561..2a189a3ff53 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -5566,7 +5566,8 @@ impl ThreadEventStream {id,status,error: None,- summary: Vec::new(),+ summary: acp_thread::MessageContent::default(),+ meta: None,},))).ok();diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rsindex 5ac8971aa86..e24db7f1fc3 100644--- a/crates/agent_ui/src/conversation_view.rs+++ b/crates/agent_ui/src/conversation_view.rs@@ -11428,33 +11428,51 @@ pub(crate) mod tests {let search_bar = thread_view.read_with(cx, |view, _| view.thread_search_bar.clone()).expect("thread search bar should be open");- let resource =- acp_v1::EmbeddedResource::new(acp_v1::EmbeddedResourceResource::TextResourceContents(- acp_v1::TextResourceContents::new("retained resource details", "summary://context")- .mime_type("text/markdown".to_string()),- ));+ let source_json = json!([+ {+ "type": "text",+ "text": "Retained summary",+ "_meta": {"origin": {"parts": ["context", {"revision": 1}]}}+ },+ {+ "type": "resource",+ "resource": {+ "text": "retained resource details",+ "uri": "summary://context",+ "mimeType": "text/markdown",+ "_meta": {"snapshot": {"revision": 2}}+ },+ "_meta": {"origin": {"kind": "summary"}}+ },+ {+ "type": "_future_summary",+ "payload": {"nested": [1, {"value": "original"}]},+ "_meta": {"origin": {"kind": "future"}}+ }+ ]);+ let source: Vec<acp_v2::ContentBlock> =+ serde_json::from_value(source_json.clone()).expect("valid shared summary content");- for (update, query) in [+ for (update, query, expected_source) in [(- acp_v1::CompactionUpdate::new("failed", acp_v1::CompactionStatus::Failed)+ acp_v2::CompactionUpdate::new("failed", acp_v2::CompactionStatus::Failed).error("model *still* unavailable <details>"),"model *still* unavailable <details>",+ Vec::new(),),(- acp_v1::CompactionUpdate::new("completed", acp_v1::CompactionStatus::Completed)- .summary(vec![- acp_v1::ContentBlock::Text(acp_v1::TextContent::new("Retained summary")),- acp_v1::ContentBlock::Resource(resource),- ]),+ acp_v2::CompactionUpdate::new("completed", acp_v2::CompactionStatus::Completed)+ .summary(source.clone()),"retained resource details",+ source,),] {- thread- .update(cx, |thread, cx| {- thread- .handle_session_update(acp_v1::SessionUpdate::CompactionUpdate(update), cx)- })- .expect("failed to receive compaction details");+ let compaction_id = update.compaction_id.clone();+ let status = update.status.clone();+ let is_error = expected_source.is_empty();+ thread.update(cx, |thread, cx| {+ thread.upsert_context_compaction_update(update, cx);+ });cx.run_until_parked();let (entry_index, markdown) = thread.read_with(cx, |thread, cx| {@@ -11467,10 +11485,17 @@ pub(crate) mod tests {let AgentThreadEntry::ContextCompaction(compaction) = entry else {panic!("expected a compaction entry");};+ assert_eq!(compaction.summary.source_blocks(), expected_source);+ if !is_error {+ assert_eq!(+ serde_json::to_value(compaction.summary.source_blocks())+ .expect("serializable shared summary"),+ source_json+ );+ }let markdown = compaction.summary- .iter()- .filter_map(|content| content.markdown())+ .markdowns().chain(compaction.error.iter()).find(|markdown| markdown.read(cx).source().contains(query)).expect("compaction should retain searchable details")@@ -11497,6 +11522,65 @@ pub(crate) mod tests {"the visible compaction details should be highlighted",);+ let replacement_query = "updated searchable details";+ let replacement_source = if is_error {+ Vec::new()+ } else {+ vec![acp_v2::ContentBlock::Text(acp_v2::TextContent::new(+ replacement_query,+ ))]+ };+ let replacement = acp_v2::CompactionUpdate::new(compaction_id.clone(), status.clone());+ let replacement = if is_error {+ replacement.error(replacement_query)+ } else {+ replacement.summary(replacement_source.clone())+ };+ thread.update(cx, |thread, cx| {+ thread.upsert_context_compaction_update(replacement, cx);+ });+ cx.run_until_parked();+ cx.executor()+ .advance_clock(super::thread_search_bar::SEARCH_UPDATE_DEBOUNCE * 2);+ cx.run_until_parked();+ assert_eq!(+ search_bar.read_with(cx, |search_bar, _| search_bar.match_count()),+ 0,+ "replacement should refresh search without changing the query"+ );+ assert!(markdown.read_with(cx, |markdown, _| markdown.search_highlights().is_empty()));+ let replacement_markdown = thread.read_with(cx, |thread, cx| {+ let AgentThreadEntry::ContextCompaction(compaction) = thread+ .entries()+ .get(entry_index)+ .expect("compaction entry should remain")+ else {+ panic!("replacement should retain the compaction entry");+ };+ assert_eq!(compaction.summary.source_blocks(), replacement_source);+ compaction+ .summary+ .markdowns()+ .chain(compaction.error.iter())+ .find(|markdown| markdown.read(cx).source().as_ref() == replacement_query)+ .expect("replacement should have searchable details")+ .clone()+ });+ search_bar.update_in(cx, |search_bar, window, cx| {+ search_bar.query_editor.update(cx, |editor, cx| {+ editor.set_text(replacement_query, window, cx);+ });+ search_bar.update_matches(window, cx);+ });+ cx.run_until_parked();+ assert_eq!(+ search_bar.read_with(cx, |search_bar, _| search_bar.match_count()),+ 1+ );+ assert!(replacement_markdown.read_with(cx, |markdown, _| {+ !markdown.search_highlights().is_empty()+ }));+thread_view.update_in(cx, |view, window, cx| {view.toggle_compaction_expansion(entry_index, window, cx);});@@ -11505,7 +11589,50 @@ pub(crate) mod tests {search_bar.read_with(cx, |search_bar, _| search_bar.match_count()),0);- assert!(markdown.read_with(cx, |markdown, _| markdown.search_highlights().is_empty()));+ assert!(replacement_markdown.read_with(cx, |markdown, _| {+ markdown.search_highlights().is_empty()+ }));++ thread_view.update_in(cx, |view, window, cx| {+ view.toggle_compaction_expansion(entry_index, window, cx);+ });+ cx.run_until_parked();+ assert_eq!(+ search_bar.read_with(cx, |search_bar, _| search_bar.match_count()),+ 1+ );+ thread.update(cx, |thread, cx| {+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new(compaction_id, status)+ .summary(None::<Vec<acp_v2::ContentBlock>>)+ .error(None::<String>),+ cx,+ );+ });+ cx.run_until_parked();+ cx.executor()+ .advance_clock(super::thread_search_bar::SEARCH_UPDATE_DEBOUNCE * 2);+ cx.run_until_parked();+ thread.read_with(cx, |thread, _| {+ let AgentThreadEntry::ContextCompaction(compaction) = thread+ .entries()+ .get(entry_index)+ .expect("compaction entry should remain")+ else {+ panic!("clearing details should retain the compaction entry");+ };+ assert!(compaction.summary.source_blocks().is_empty());+ assert_eq!(compaction.summary.blocks().len(), 0);+ assert!(compaction.error.is_none());+ });+ assert_eq!(+ search_bar.read_with(cx, |search_bar, _| search_bar.match_count()),+ 0,+ "clearing visible details should refresh search"+ );+ assert!(replacement_markdown.read_with(cx, |markdown, _| {+ markdown.search_highlights().is_empty()+ }));}}diff --git a/crates/agent_ui/src/conversation_view/thread_search_bar.rs b/crates/agent_ui/src/conversation_view/thread_search_bar.rsindex 18116053ca1..4a78597064e 100644--- a/crates/agent_ui/src/conversation_view/thread_search_bar.rs+++ b/crates/agent_ui/src/conversation_view/thread_search_bar.rs@@ -994,8 +994,8 @@ fn compaction_markdowns() -> impl Iterator<Item = Entity<Markdown>> + '_ {compaction.summary- .iter()- .filter_map(|content| content.markdown().cloned())+ .markdowns()+ .cloned().chain(compaction.error.iter().cloned()).filter(move |_| is_expanded)}@@ -1004,42 +1004,42 @@ fn compaction_markdowns(mod tests {use super::*;use acp_thread::{- ContentBlock, ContextCompaction, ContextCompactionId, ContextCompactionStatus,+ ContextCompaction, ContextCompactionId, ContextCompactionStatus, MessageContent,};- use agent_client_protocol::schema::v1 as acp_v1;+ use agent_client_protocol::schema::v2 as acp_v2;use language::LanguageRegistry;+ use util::paths::PathStyle;#[gpui::test]fn test_compaction_markdowns_include_summary_and_error(cx: &mut App) {- let summary = cx.new(|cx| Markdown::new("summary match".into(), None, None, cx));let error = cx.new(|cx| Markdown::new("error match".into(), None, None, cx));let language_registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));- let unsupported_block = ContentBlock::new_output(- acp_thread::content::from_v1(acp_v1::ContentBlock::Audio(acp_v1::AudioContent::new(- "YXVkaW8=",- "audio/wav",- )))- .expect("known v1 audio content"),+ let mut summary = MessageContent::new(+ acp_v2::ContentBlock::Text(acp_v2::TextContent::new("summary match")),&language_registry,+ PathStyle::local(),cx,);- let unsupported = unsupported_block- .markdown()- .expect("audio fallback")- .clone();+ summary.append(+ acp_v2::ContentBlock::Audio(acp_v2::AudioContent::new("YXVkaW8=", "audio/wav")),+ &language_registry,+ PathStyle::local(),+ cx,+ );+ let mut expected_markdowns = summary.markdowns().cloned().collect::<Vec<_>>();+ assert_eq!(expected_markdowns.len(), 2);+ expected_markdowns.push(error.clone());let compaction = ContextCompaction {id: ContextCompactionId("compaction".into()),status: ContextCompactionStatus::Failed,- summary: vec![- ContentBlock::from_markdown(summary.clone()),- unsupported_block,- ],- error: Some(error.clone()),+ summary,+ error: Some(error),+ meta: None,};assert!(compaction_markdowns(&compaction, false).next().is_none());let markdowns = compaction_markdowns(&compaction, true).collect::<Vec<_>>();- assert_eq!(markdowns, vec![summary, unsupported, error]);+ assert_eq!(markdowns, expected_markdowns);}}diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 134dc146b84..570d8993c07 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -4518,7 +4518,7 @@ impl ThreadView {let is_compacting = compaction.is_in_progress();let summary = &compaction.summary;let error = compaction.error.clone();- let has_details = !summary.is_empty() || error.is_some();+ let has_details = summary.blocks().len() > 0 || error.is_some();let is_expanded = self.entry_view_state.read(cx)@@ -4582,23 +4582,18 @@ impl ThreadView {.when_some(details, |this, (summary, error)| {this.border_color(self.tool_card_border_color(cx)).bg(cx.theme().colors().editor_background.opacity(0.2))- .when(!summary.is_empty(), |this| {+ .when(summary.blocks().len() > 0, |this| {this.child(v_flex().id(("compaction-summary", entry_ix)).p_2().gap_2().text_ui(cx)- .children(summary.iter().enumerate().map(+ .children(summary.blocks().enumerate().map(|(content_ix, content)| {self.render_output_content_block(- entry_ix,- content_ix,- content.as_view(),- None,- true,- window,- cx,+ entry_ix, content_ix, content, None, true,+ window, cx,)},)),