Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
acp_thread: Apply v2 metadata patches by key (#65709)
Ben Brandt56934ec0560b
diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rsindex c70eae242e8..0dd9876a737 100644--- a/crates/acp_thread/src/acp_thread.rs+++ b/crates/acp_thread/src/acp_thread.rs@@ -61,6 +61,37 @@ use util::path_list::PathList;use util::{ResultExt, get_default_system_shell_preferring_bash, paths::PathStyle};use uuid::Uuid;+pub(crate) enum MetadataUpdate {+ V1(MaybeUndefined<acp_v2::Meta>),+ V2(MaybeUndefined<acp_v2::Meta>),+}++impl MetadataUpdate {+ pub(crate) fn apply(self, stored: &mut Option<acp_v2::Meta>) -> bool {+ if matches!(+ &self,+ Self::V1(MaybeUndefined::Undefined) | Self::V2(MaybeUndefined::Undefined)+ ) {+ return false;+ }+ let previous = stored.clone();+ match self {+ Self::V1(update) => {+ *stored = update.take();+ }+ Self::V2(update) => {+ let mut metadata = stored.take().map(MaybeUndefined::Value).unwrap_or_default();+ acp_v2::apply_meta_update(&mut metadata, update);+ *stored = metadata.take();+ // Empty entity metadata and absent metadata have the same meaning in v2.+ return stored.as_ref().filter(|metadata| !metadata.is_empty())+ != previous.as_ref().filter(|metadata| !metadata.is_empty());+ }+ }+ *stored != previous+ }+}+/// Returned when the model stops because it exhausted its output token budget.#[derive(Debug)]pub struct MaxOutputTokensError;@@ -894,6 +925,7 @@ impl ContextCompaction {fn apply_update(&mut self,update: acp_v2::CompactionUpdate,+ metadata: MetadataUpdate,language_registry: &Arc<LanguageRegistry>,cx: &mut App,) {@@ -919,11 +951,7 @@ impl ContextCompaction {}}}- match update.meta {- MaybeUndefined::Undefined => {}- MaybeUndefined::Null => self.meta = None,- MaybeUndefined::Value(meta) => self.meta = Some(meta),- }+ metadata.apply(&mut self.meta);}fn append_summary(@@ -1326,7 +1354,11 @@ impl ToolCall {.and_then(|input| markdown_for_raw_output(input, &language_registry, cx));let meta = match patch.meta {ToolMetadataPatch::Legacy(meta) => meta,- ToolMetadataPatch::Protocol(meta) => meta.take(),+ ToolMetadataPatch::Protocol(meta) => {+ let mut stored = None;+ MetadataUpdate::V2(meta).apply(&mut stored);+ stored+ }};let tool_name = name.clone().or_else(|| tool_name_from_meta(&meta));let subagent_session_info = subagent_session_info_from_meta(&meta);@@ -1522,9 +1554,9 @@ impl ToolCall {}}ToolMetadataPatch::Protocol(meta) => {- let meta_changed = !meta.is_undefined();+ let cleared = matches!(&meta, MaybeUndefined::Null);+ let meta_changed = MetadataUpdate::V2(meta).apply(&mut self.meta) || cleared;if meta_changed {- self.meta = meta.take();self.subagent_session_info = subagent_session_info_from_meta(&self.meta);self.sandbox_authorization_details =sandbox_authorization_details_from_meta(&self.meta);@@ -4472,10 +4504,10 @@ impl AcpThread {self.update_tool_call(tool_call_update, cx)?;}acp_v1::SessionUpdate::CompactionUpdate(compaction_update) => {- self.upsert_context_compaction_update(- compaction::update_from_v1(compaction_update).map_err(acp_v1::Error::from)?,- cx,- );+ let mut update =+ compaction::update_from_v1(compaction_update).map_err(acp_v1::Error::from)?;+ let metadata = MetadataUpdate::V1(mem::take(&mut update.meta));+ self.upsert_context_compaction_update_inner(update, metadata, cx);}acp_v1::SessionUpdate::CompactionSummaryChunk(summary_chunk) => {self.append_context_compaction_summary(@@ -4490,7 +4522,7 @@ impl AcpThread {self.push_notice(notices::from_v1(notice).map_err(acp_v1::Error::from)?, cx);}acp_v1::SessionUpdate::SessionInfoUpdate(info_update) => {- self.update_session_info(session_info_update_from_v1(info_update), cx);+ self.update_session_info(info_update, cx);}acp_v1::SessionUpdate::AvailableCommandsUpdate(acp_v1::AvailableCommandsUpdate {available_commands,@@ -4608,11 +4640,7 @@ impl AcpThread {message_content.replace(replacement, &language_registry, path_style, cx);}}- match meta {- MaybeUndefined::Undefined => {}- MaybeUndefined::Null => *message_meta = None,- MaybeUndefined::Value(meta) => *message_meta = Some(meta),- }+ MetadataUpdate::V2(meta).apply(message_meta);self.emit_message_update(location, previous_entry_count, cx);Ok(())}@@ -5201,8 +5229,18 @@ impl AcpThread {}pub fn upsert_context_compaction_update(+ &mut self,+ mut update: acp_v2::CompactionUpdate,+ cx: &mut Context<Self>,+ ) {+ let metadata = MetadataUpdate::V2(mem::take(&mut update.meta));+ self.upsert_context_compaction_update_inner(update, metadata, cx);+ }++ fn upsert_context_compaction_update_inner(&mut self,update: acp_v2::CompactionUpdate,+ metadata: MetadataUpdate,cx: &mut Context<Self>,) {let id = ContextCompactionId(update.compaction_id.0.clone());@@ -5220,7 +5258,7 @@ impl AcpThread {_ => None,}){- compaction.apply_update(update, &language_registry, cx);+ compaction.apply_update(update, metadata, &language_registry, cx);cx.emit(AcpThreadEvent::EntryUpdated(entry_index));return;}@@ -5232,7 +5270,7 @@ impl AcpThread {summary: MessageContent::default(),meta: None,};- compaction.apply_update(update, &language_registry, cx);+ compaction.apply_update(update, metadata, &language_registry, cx);self.push_entry(AgentThreadEntry::ContextCompaction(compaction), cx);}@@ -5308,12 +5346,12 @@ impl AcpThread {pub fn update_session_info(&mut self,- update: acp_v2::SessionInfoUpdate,+ update: impl Into<AgentSessionInfoUpdate>,cx: &mut Context<Self>,) {+ let update = update.into();let previous_title = self.session_info.title.clone();- let had_provisional =- !update.title.is_undefined() && self.provisional_title.take().is_some();+ let had_provisional = update.has_title() && self.provisional_title.take().is_some();let changed = self.session_info.apply_update(update);if self.session_info.title != previous_title || had_provisional {cx.emit(AcpThreadEvent::TitleUpdated);@@ -12709,6 +12747,240 @@ mod tests {}}+ #[gpui::test]+ async fn test_v2_entity_metadata_patches_by_key(cx: &mut TestAppContext) {+ init_test(cx);+ let mut messages = Vec::new();+ for kind in [+ MessageKind::User,+ MessageKind::Assistant,+ MessageKind::Thought,+ ] {+ messages.push((kind, new_test_thread(cx).await));+ }+ let thread = new_test_thread(cx).await;+ let snapshot_meta: acp_v2::Meta =+ serde_json::from_value(json!({"literal": null})).expect("snapshot metadata");+ let block = acp_v2::ContentBlock::Text(+ acp_v2::TextContent::new("snapshot").meta(snapshot_meta.clone()),+ );+ for (patch, expected) in [+ (None, json!(null)),+ (+ Some(+ json!({"keep": 1, "remove": true, "absent": null, "nested": {"old": 1, "literal": null}}),+ ),+ json!({"keep": 1, "remove": true, "nested": {"old": 1, "literal": null}}),+ ),+ (+ Some(json!({"remove": null, "added": [], "nested": {"new": 2, "literal": null}})),+ json!({"keep": 1, "added": [], "nested": {"new": 2, "literal": null}}),+ ),+ (+ Some(json!({})),+ json!({"keep": 1, "added": [], "nested": {"new": 2, "literal": null}}),+ ),+ (+ None,+ json!({"keep": 1, "added": [], "nested": {"new": 2, "literal": null}}),+ ),+ (+ Some(json!({"keep": null, "nested": null})),+ json!({"added": []}),+ ),+ (Some(json!(null)), json!(null)),+ (+ Some(json!({"gone": null, "last": {"literal": null}})),+ json!({"last": {"literal": null}}),+ ),+ ] {+ let metadata = patch.map_or(MaybeUndefined::Undefined, |patch| {+ serde_json::from_value::<MaybeUndefined<acp_v2::Meta>>(patch)+ .expect("metadata patch")+ });+ let expected: Option<acp_v2::Meta> =+ serde_json::from_value(expected).expect("expected stored metadata");+ for (kind, message) in &messages {+ message.update(cx, |thread, cx| {+ match kind {+ MessageKind::User => thread.upsert_user_message(+ acp_v2::UserMessage::new("metadata")+ .content(vec![block.clone()])+ .meta(metadata.clone()),+ cx,+ ),+ MessageKind::Assistant => thread.upsert_assistant_message(+ acp_v2::AgentMessage::new("metadata")+ .content(vec![block.clone()])+ .meta(metadata.clone()),+ cx,+ ),+ MessageKind::Thought => thread.upsert_thought(+ acp_v2::AgentThought::new("metadata")+ .content(vec![block.clone()])+ .meta(metadata.clone()),+ cx,+ ),+ }+ .expect("message upsert");+ let (_, content, stored) = only_keyed_message(thread);+ assert_eq!(stored, &expected, "{kind:?}");+ assert_eq!(content.source_blocks(), std::slice::from_ref(&block));+ thread+ .append_message_chunk(+ *kind,+ acp_v2::ContentChunk::new("chunk".into(), "metadata")+ .meta(snapshot_meta.clone()),+ cx,+ )+ .expect("message chunk");+ assert_eq!(only_keyed_message(thread).2, &expected);+ });+ }+ thread.update(cx, |thread, cx| {+ thread+ .upsert_wire_tool_call(+ acp_v2::ToolCallUpdate::new("metadata").meta(metadata.clone()),+ cx,+ )+ .expect("tool upsert");+ assert_eq!(+ thread.tool_call(&"metadata".into()).expect("tool").1.meta,+ expected+ );+ thread+ .upsert_display_terminal(+ "metadata".into(),+ DisplayTerminalPatch {+ meta: metadata.clone(),+ output: MaybeUndefined::Value(DisplayTerminalOutput {+ data: b"snapshot".to_vec(),+ meta: Some(snapshot_meta.clone()),+ }),+ exit_status: MaybeUndefined::Value(+ acp_v2::TerminalExitStatus::new().meta(snapshot_meta.clone()),+ ),+ ..Default::default()+ },+ cx,+ )+ .expect("terminal upsert");+ let terminal = thread.terminal("metadata".into()).expect("terminal");+ let terminal = terminal.read(cx);+ let display = terminal.display_state().expect("display");+ assert_eq!(display.meta, expected);+ assert_eq!(display.output_meta.as_ref(), Some(&snapshot_meta));+ assert_eq!(+ terminal+ .output()+ .expect("exit snapshot")+ .exit_status+ .meta+ .as_ref(),+ Some(&snapshot_meta)+ );+ thread.upsert_context_compaction_update(+ acp_v2::CompactionUpdate::new("metadata", acp_v2::CompactionStatus::InProgress)+ .summary(vec![block.clone()])+ .meta(metadata.clone()),+ cx,+ );+ let compaction = thread+ .entries+ .iter()+ .find_map(|entry| match entry {+ AgentThreadEntry::ContextCompaction(compaction) => Some(compaction),+ _ => None,+ })+ .expect("compaction");+ assert_eq!(compaction.meta, expected);+ assert_eq!(+ compaction.summary.source_blocks(),+ std::slice::from_ref(&block)+ );+ thread.append_context_compaction_summary(+ acp_v2::CompactionSummaryChunk::new("metadata", "chunk".into())+ .meta(snapshot_meta.clone()),+ cx,+ );+ thread.update_session_info(acp_v2::SessionInfoUpdate::new().meta(metadata), cx);+ assert_eq!(thread.session_info().meta, expected);+ });+ }+ let permission = thread.update(cx, |thread, cx| {+ let permission = thread+ .request_tool_call_update_authorization_with_id(+ acp_v2::ToolCallUpdate::new("metadata").meta(+ serde_json::from_value::<acp_v2::Meta>(json!({"permission": true}))+ .expect("permission metadata"),+ ),+ PermissionOptions::Flat(vec![acp_v2::PermissionOption::new(+ "allow",+ "Allow",+ acp_v2::PermissionOptionKind::AllowOnce,+ )]),+ AuthorizationKind::PermissionGrant,+ cx,+ )+ .expect("permission subject");+ assert_eq!(+ thread.tool_call(&"metadata".into()).expect("tool").1.meta,+ Some(+ serde_json::from_value(json!({"last": {"literal": null}, "permission": true}))+ .expect("merged permission metadata")+ )+ );+ thread.cancel_permission_request(permission.0, cx);+ permission.1+ });+ assert!(matches!(+ permission.await,+ RequestPermissionOutcome::Cancelled+ ));+ }++ #[gpui::test]+ async fn test_v1_compaction_metadata_keeps_replacement_semantics(cx: &mut TestAppContext) {+ init_test(cx);+ let thread = new_test_thread(cx).await;+ for (patch, expected) in [+ (+ json!({"_meta": {"first": 1, "literal": null}}),+ json!({"first": 1, "literal": null}),+ ),+ (+ json!({"_meta": {"replacement": 2}}),+ json!({"replacement": 2}),+ ),+ (json!({"_meta": {}}), json!({})),+ (json!({}), json!({})),+ (json!({"_meta": null}), json!(null)),+ ] {+ thread.update(cx, |thread, cx| {+ let mut patch = patch;+ let fields = patch.as_object_mut().expect("update object");+ fields.insert("compactionId".into(), json!("legacy"));+ fields.insert("status".into(), json!("in_progress"));+ thread+ .handle_session_update(+ acp_v1::SessionUpdate::CompactionUpdate(+ serde_json::from_value(patch).expect("v1 compaction"),+ ),+ cx,+ )+ .expect("legacy update");+ let Some(AgentThreadEntry::ContextCompaction(compaction)) = thread.entries.first()+ else {+ panic!("compaction");+ };+ assert_eq!(+ serde_json::to_value(&compaction.meta).expect("metadata JSON"),+ expected+ );+ });+ }+ }+#[gpui::test]async fn test_keyed_snapshots_supersede_only_their_own_buffered_text(cx: &mut TestAppContext) {init_test(cx);@@ -14462,6 +14734,8 @@ mod tests {"compaction".into(),serde_json::json!({"nested": [1, "retained"]}),)]);+ let mut expected_metadata = metadata.clone();+ expected_metadata.insert("original".into(), json!(true));thread.update(cx, |thread, cx| {thread.upsert_context_compaction_update(acp_v2::CompactionUpdate::new("first", acp_v2::CompactionStatus::Completed)@@ -14491,7 +14765,7 @@ mod tests {ContextCompactionStatus::Other("_future".into()));assert_eq!(first.summary.source_blocks(), source);- assert_eq!(first.meta.as_ref(), Some(&metadata));+ assert_eq!(first.meta.as_ref(), Some(&expected_metadata));assert!(!thread.is_compacting());});assert_eq!(@@ -14523,7 +14797,7 @@ mod tests {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.meta, Some(expected_metadata.clone()));assert_eq!(first.error@@ -15314,7 +15588,10 @@ mod tests {}assert_eq!(thread.tool_call(&id).expect("tool").1.meta,- Some(acp_v2::Meta::new())+ Some(+ serde_json::from_value(json!({"opaque": {"nested": [1, 2]}}))+ .expect("retained metadata")+ ));thread.upsert_wire_tool_call(acp_v2::ToolCallUpdate::new("patch").title(" "), cx)@@ -15609,9 +15886,19 @@ mod tests {acp_v2::ToolCallUpdate::new("metadata").meta(acp_v2::Meta::new()),cx,)- .expect("authoritative metadata replacement");+ .expect("empty metadata patch");let (_, call) = thread.tool_call(&id).expect("tool");- assert_eq!(call.meta, Some(acp_v2::Meta::new()));+ assert_eq!(call.meta.as_ref(), Some(&newer_meta));+ assert_eq!(call.tool_name.as_deref(), Some("legacy_name"));+ assert!(call.subagent_session_info.is_some());+ thread+ .upsert_wire_tool_call(+ acp_v2::ToolCallUpdate::new("metadata").meta(None::<acp_v2::Meta>),+ cx,+ )+ .expect("explicit metadata clear");+ let (_, call) = thread.tool_call(&id).expect("tool");+ assert_eq!(call.meta, None);assert_eq!(call.tool_name, None);assert!(call.subagent_session_info.is_none());assert_eq!(call.label.read(cx).source(), "Tool call");diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rsindex 86d0be54dfd..9ede73f7abd 100644--- a/crates/acp_thread/src/connection.rs+++ b/crates/acp_thread/src/connection.rs@@ -443,15 +443,29 @@ impl AgentSessionInfo {}}- pub fn apply_update(&mut self, update: acp_v2::SessionInfoUpdate) -> bool {+ pub fn apply_update(&mut self, update: impl Into<AgentSessionInfoUpdate>) -> bool {+ let (title, updated_at, metadata) = match update.into() {+ AgentSessionInfoUpdate::V1(update) => (+ update.title,+ update.updated_at,+ crate::MetadataUpdate::V1(+ update.meta.map(MaybeUndefined::Value).unwrap_or_default(),+ ),+ ),+ AgentSessionInfoUpdate::V2(update) => (+ update.title,+ update.updated_at,+ crate::MetadataUpdate::V2(update.meta),+ ),+ };let mut changed = false;- if !update.title.is_undefined() {- let title = update.title.take().map(SharedString::from);+ if !title.is_undefined() {+ let title = title.take().map(SharedString::from);changed |= self.title != title;self.title = title;}- let updated_at = match update.updated_at {+ let updated_at = match updated_at {MaybeUndefined::Undefined => None,MaybeUndefined::Null => Some(None),MaybeUndefined::Value(updated_at) => match DateTime::parse_from_rfc3339(&updated_at) {@@ -467,23 +481,37 @@ impl AgentSessionInfo {self.updated_at = updated_at;}- if !update.meta.is_undefined() {- let meta = update.meta.take();- changed |= self.meta != meta;- self.meta = meta;- }+ changed |= metadata.apply(&mut self.meta);changed}}-pub fn session_info_update_from_v1(update: acp_v1::SessionInfoUpdate) -> acp_v2::SessionInfoUpdate {- let mut converted = acp_v2::SessionInfoUpdate::new()- .title(update.title)- .updated_at(update.updated_at);- if let Some(meta) = update.meta {- converted = converted.meta(meta);+/// Retains wire provenance because v1 metadata replaces while v2 metadata patches.+#[derive(Debug, Clone, PartialEq)]+pub enum AgentSessionInfoUpdate {+ V1(acp_v1::SessionInfoUpdate),+ V2(acp_v2::SessionInfoUpdate),+}++impl AgentSessionInfoUpdate {+ pub(crate) fn has_title(&self) -> bool {+ match self {+ Self::V1(update) => !update.title.is_undefined(),+ Self::V2(update) => !update.title.is_undefined(),+ }+ }+}++impl From<acp_v1::SessionInfoUpdate> for AgentSessionInfoUpdate {+ fn from(update: acp_v1::SessionInfoUpdate) -> Self {+ Self::V1(update)+ }+}++impl From<acp_v2::SessionInfoUpdate> for AgentSessionInfoUpdate {+ fn from(update: acp_v2::SessionInfoUpdate) -> Self {+ Self::V2(update)}- converted}#[derive(Debug, Clone)]@@ -491,7 +519,7 @@ pub enum SessionListUpdate {Refresh,SessionInfo {session_id: acp_v2::SessionId,- update: acp_v2::SessionInfoUpdate,+ update: AgentSessionInfoUpdate,},}@@ -1649,6 +1677,13 @@ mod tests {)])),true,),+ (+ json!({"_meta": {"literal": null}}),+ original.title.clone(),+ original.updated_at,+ Some(acp_v2::Meta::from_iter([("literal".into(), json!(null))])),+ true,+ ),(json!({"_meta": null}),original.title.clone(),@@ -1659,14 +1694,8 @@ mod tests {] {let legacy: acp_v1::SessionInfoUpdate =serde_json::from_value(wire).expect("legacy patch");- let converted = session_info_update_from_v1(legacy.clone());- assert_eq!(- serde_json::to_value(&converted).expect("shared patch wire"),- serde_json::to_value(&legacy).expect("normalized legacy patch wire")- );-let mut info = original.clone();- assert_eq!(info.apply_update(converted.clone()), changed);+ assert_eq!(info.apply_update(legacy.clone()), changed);assert_eq!(info,AgentSessionInfo {@@ -1676,7 +1705,7 @@ mod tests {..original.clone()});- assert!(!info.apply_update(converted), "identical patch is a no-op");+ assert!(!info.apply_update(legacy), "identical patch is a no-op");}let mut info = original.clone();@@ -1688,7 +1717,7 @@ mod tests {..original.clone()});- assert!(info.apply_update(acp_v2::SessionInfoUpdate::new().meta(acp_v2::Meta::new())));+ assert!(!info.apply_update(acp_v2::SessionInfoUpdate::new().meta(acp_v2::Meta::new())));assert_eq!(info.meta, Some(acp_v2::Meta::new()));let mut info = original.clone();@@ -1710,4 +1739,44 @@ mod tests {acp_v2::SessionInfoUpdate::new().updated_at("invalid private timestamp")));}++ #[test]+ fn session_info_v2_metadata_patches_report_only_effective_changes() {+ let mut info = AgentSessionInfo::new("metadata");+ for (patch, expected, changed) in [+ (json!({"_meta": {"missing": null}}), json!({}), false),+ (json!({"_meta": {}}), json!({}), false),+ (+ json!({"_meta": {"keep": 1, "nested": {"old": true, "literal": null}}}),+ json!({"keep": 1, "nested": {"old": true, "literal": null}}),+ true,+ ),+ (+ json!({"_meta": {"nested": {"new": true, "literal": null}}}),+ json!({"keep": 1, "nested": {"new": true, "literal": null}}),+ true,+ ),+ (+ json!({"_meta": {"unknown": null}}),+ json!({"keep": 1, "nested": {"new": true, "literal": null}}),+ false,+ ),+ (+ json!({"_meta": {"keep": null}}),+ json!({"nested": {"new": true, "literal": null}}),+ true,+ ),+ (json!({"_meta": null}), json!(null), true),+ (json!({"_meta": null}), json!(null), false),+ ] {+ let update: acp_v2::SessionInfoUpdate =+ serde_json::from_value(patch).expect("v2 session information");+ assert_eq!(info.apply_update(update.clone()), changed);+ assert_eq!(+ serde_json::to_value(&info.meta).expect("metadata JSON"),+ expected+ );+ assert!(!info.apply_update(update), "repeated patch is a no-op");+ }+ }}diff --git a/crates/acp_thread/src/terminal.rs b/crates/acp_thread/src/terminal.rsindex dd79565c53b..ba9b59507c5 100644--- a/crates/acp_thread/src/terminal.rs+++ b/crates/acp_thread/src/terminal.rs@@ -791,9 +791,7 @@ impl Terminal {);});}- if !meta.is_undefined() {- state.meta = meta.take();- }+ crate::MetadataUpdate::V2(meta).apply(&mut state.meta);if let Some(meta) = output_meta {state.output_meta = meta;}diff --git a/crates/agent_servers/src/acp/v1.rs b/crates/agent_servers/src/acp/v1.rsindex 5db122b3cc4..3b82b3dbdd8 100644--- a/crates/agent_servers/src/acp/v1.rs+++ b/crates/agent_servers/src/acp/v1.rs@@ -227,8 +227,9 @@ impl AcpSessionList {pub(super) fn send_info_update(&self,session_id: acp_v2::SessionId,- update: acp_v2::SessionInfoUpdate,+ update: impl Into<acp_thread::AgentSessionInfoUpdate>,) {+ let update = update.into();self.updates_tx.try_send(acp_thread::SessionListUpdate::SessionInfo { session_id, update }).log_err();@@ -3547,7 +3548,7 @@ mod tests {json!({"updatedAt": null, "_meta": {}}),Some("Agent title"),Some("Agent title"),- Some(acp_v2::Meta::new()),+ Some(v2_terminal_meta("session")),None,),(@@ -3575,7 +3576,7 @@ mod tests {panic!("session-info list update");};assert_eq!(updated_id, session_id);- assert_eq!(update, expected_update);+ assert_eq!(update, expected_update.into());listed.apply_update(update);assert_eq!(listed.title.as_deref(), expected_list_title);assert_eq!(listed.meta, expected_meta);@@ -3960,7 +3961,13 @@ mod tests {"replacement");assert_eq!(tool.terminals().cloned().collect::<Vec<_>>(), terminals);- assert_eq!(tool.meta, Some(v2_terminal_meta("replacement")));+ assert_eq!(+ tool.meta,+ Some(+ serde_json::from_value(json!({"scope": "replacement", "old": true}))+ .expect("patched metadata")+ )+ );assert_eq!(tool.raw_input, Some(json!({"path": "./a/../b"})));assert_eq!(tool.locations.len(), 1);});@@ -4173,7 +4180,7 @@ mod tests {panic!("historical updates retain first-seen rows");};assert_eq!(user.content.source_blocks().len(), 3);- assert_eq!(user.meta, Some(acp_v2::Meta::new()));+ assert_eq!(user.meta, Some(v2_terminal_meta("user")));assert_eq!(later.content.to_markdown(cx), "later");let [AssistantMessageChunk::Message { block, meta, .. },@@ -9532,10 +9539,7 @@ fn handle_session_notification(if let acp::SessionUpdate::SessionInfoUpdate(info_update) = ¬ification.update&& let Some(session_list) = ctx.session_list.borrow().as_ref(){- session_list.send_info_update(- session_id.clone(),- acp_thread::session_info_update_from_v1(info_update.clone()),- );+ session_list.send_info_update(session_id.clone(), info_update.clone());}// Abandoned loads can keep replaying until their wire operation settles.diff --git a/crates/agent_servers/src/acp/v2.rs b/crates/agent_servers/src/acp/v2.rsindex 7641fb2194c..13bef20f9cf 100644--- a/crates/agent_servers/src/acp/v2.rs+++ b/crates/agent_servers/src/acp/v2.rs@@ -1219,9 +1219,10 @@ impl AgentSessionList for V2SessionList {information.apply_update(acp::SessionInfoUpdate::new().title(session.title)- .updated_at(session.updated_at)- .meta(session.meta),+ .updated_at(session.updated_at),);+ // List metadata is a snapshot, so null-valued keys are data.+ information.meta = session.meta;information}).collect(),@@ -2201,6 +2202,8 @@ done.cwd(Some(acp::AbsolutePath::new(session_path("b")))).meta(meta("request")));+ let mut information_metadata = meta("information");+ information_metadata.insert("literal".into(), serde_json::Value::Null);responder.respond(acp::ListSessionsResponse::new(vec![@@ -2212,7 +2215,7 @@ done]).title("Saved title").updated_at("2026-10-01T10:20:30+02:00")- .meta(meta("information")),+ .meta(information_metadata.clone()),]).next_cursor("opaque/+?&").meta(meta("page")),@@ -2239,7 +2242,7 @@ done"2026-10-01T08:20:30+00:00");assert!(information.created_at.is_none());- assert_eq!(information.meta, Some(meta("information")));+ assert_eq!(information.meta, Some(information_metadata));assert_eq!(page.meta, Some(meta("page")));assert_eq!(page.next_cursor.as_deref(), Some("opaque/+?&"));