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.

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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,
)
},
)),