From e96ffb0fd3cc43ec56dcff421146f5e823b13841 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Fri, 23 Oct 2026 12:43:26 +0000 Subject: [PATCH] acp_thread: Show ACP session messages in the transcript (#66028) The RFD reports messages between sessions, such as a parent delegating work to its subagent, as `session_message` and `session_message_chunk` updates. Each transcript gets its own view: the parent's outgoing message, the subagent's incoming one. Zed dropped both. - **Transcript entry.** Session messages are a new `AgentThreadEntry::SessionMessage`, kept separate from user and assistant messages. They reuse the keyed-message path: an upsert replaces content, a chunk appends, and a message can start with a chunk. Participants come only from `session_message` upserts: one that an upsert omits keeps its earlier value, and a known participant cannot change. Chunks carry only content, so the participant fields that schema 1.12.0 still has on chunks are ignored, following the RFD revision in agentclientprotocol/agent-client-protocol#2465. v1 replaces message metadata where v2 patches it by key. - **Row.** It reads "To " or "From ". A subagent is named with its parent's title for it, as on its permission card, and the root session as "Main Agent". The name opens that session's thread; a session the conversation never learned about shows as "Unavailable Session" without a link. - **v1 stays off.** Like `subagent_update`, v1 session messages are only applied when Zed advertised the `subagents` client capability, which it does not do yet. - **Resume replay test.** A separate commit adds `v2_resume_replay_delivers_subagent_history`. It confirms that a subagent's history replayed during a v2 resume reaches the subagent. #65976's description said this wasn't handled; resume registers the parent before sending `session/resume`, so it works. Follow-up: the same RFD revision adds optional `senderMessageId` and `recipientMessageId` so each view can name the other. Once a schema release includes them, the row will jump to the linked entry instead of opening the thread, and per-delegation subagent cards can build on the same links. Release Notes: - N/A --- crates/acp_thread/src/acp_thread.rs | 382 +++++++++++++++++- .../agent_servers/src/acp/session_updates.rs | 14 + crates/agent_servers/src/acp/v1.rs | 66 ++- crates/agent_servers/src/acp/v2.rs | 88 ++++ crates/agent_ui/src/conversation_view.rs | 140 +++++++ .../conversation_view/thread_search_bar.rs | 3 + .../src/conversation_view/thread_view.rs | 130 ++++++ crates/agent_ui/src/entry_view_state.rs | 19 + 8 files changed, 806 insertions(+), 36 deletions(-) diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index 69c1d590a30..18b42f839d3 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -359,6 +359,7 @@ pub enum MessageKind { User, Assistant, Thought, + Session, } #[derive(Debug)] @@ -386,6 +387,32 @@ impl UserMessage { } } +/// A message between this session and another, such as a parent and its subagent. The +/// session that sent it is the outgoing view; the session that received it is the incoming +/// view. Either participant may be unknown. +#[derive(Debug)] +pub struct SessionMessage { + pub identity: MessageIdentity, + pub sender_session_id: Option, + pub recipient_session_id: Option, + pub meta: Option, + pub content: MessageContent, +} + +impl SessionMessage { + fn to_markdown(&self, cx: &App) -> String { + let heading = match (&self.sender_session_id, &self.recipient_session_id) { + (Some(sender), Some(recipient)) => { + format!("## Message from `{sender}` to `{recipient}`") + } + (Some(sender), None) => format!("## Message from `{sender}`"), + (None, Some(recipient)) => format!("## Message to `{recipient}`"), + (None, None) => "## Session message".to_string(), + }; + format!("{heading}\n\n{}\n\n", self.content.to_markdown(cx)) + } +} + #[derive(Debug, PartialEq)] pub struct AssistantMessage { pub chunks: Vec, @@ -475,12 +502,17 @@ enum MessageLocation { entry_index: usize, chunk_index: usize, }, + Session { + entry_index: usize, + }, } impl MessageLocation { fn entry_index(self) -> usize { match self { - Self::User { entry_index } | Self::Assistant { entry_index, .. } => entry_index, + Self::User { entry_index } + | Self::Assistant { entry_index, .. } + | Self::Session { entry_index } => entry_index, } } @@ -498,6 +530,9 @@ impl MessageLocation { | AssistantMessageChunk::Thought { block, meta, .. } => Some((block, meta)), } } + (Self::Session { .. }, AgentThreadEntry::SessionMessage(message)) => { + Some((&mut message.content, &mut message.meta)) + } _ => None, } } @@ -515,6 +550,7 @@ impl MessageLocation { pub enum AgentThreadEntry { UserMessage(UserMessage), AssistantMessage(AssistantMessage), + SessionMessage(SessionMessage), ToolCall(ToolCall), Elicitation(ElicitationEntryId), ContextCompaction(ContextCompaction), @@ -978,6 +1014,7 @@ impl AgentThreadEntry { match self { Self::UserMessage(message) => message.indented, Self::AssistantMessage(message) => message.indented, + Self::SessionMessage(_) => false, Self::ToolCall(_) => false, Self::Elicitation(_) => false, Self::ContextCompaction(_) => false, @@ -994,6 +1031,7 @@ impl AgentThreadEntry { | AssistantMessageChunk::Thought { block, .. }) = chunk; block.markdowns().any(has_pending_render) }), + Self::SessionMessage(message) => message.content.markdowns().any(has_pending_render), Self::ToolCall(call) => { has_pending_render(&call.label) || call @@ -1018,6 +1056,7 @@ impl AgentThreadEntry { match self { Self::UserMessage(message) => message.to_markdown(cx), Self::AssistantMessage(message) => message.to_markdown(cx), + Self::SessionMessage(message) => message.to_markdown(cx), Self::ToolCall(tool_call) => tool_call.to_markdown(cx), Self::Elicitation(_) => "## Input Requested\n\n".to_string(), Self::ContextCompaction(compaction) => { @@ -4253,6 +4292,7 @@ impl AcpThread { AgentThreadEntry::ToolCall(_) | AgentThreadEntry::Elicitation(_) | AgentThreadEntry::AssistantMessage(_) + | AgentThreadEntry::SessionMessage(_) | AgentThreadEntry::ContextCompaction(_) => {} } } @@ -4618,6 +4658,7 @@ impl AcpThread { AgentThreadEntry::ToolCall(_) | AgentThreadEntry::Elicitation(_) | AgentThreadEntry::AssistantMessage(_) + | AgentThreadEntry::SessionMessage(_) | AgentThreadEntry::ContextCompaction(_) => {} } } @@ -4640,6 +4681,7 @@ impl AcpThread { AgentThreadEntry::ToolCall(_) | AgentThreadEntry::Elicitation(_) | AgentThreadEntry::AssistantMessage(_) + | AgentThreadEntry::SessionMessage(_) | AgentThreadEntry::ContextCompaction(_) => {} } } @@ -4652,6 +4694,7 @@ impl AcpThread { match entry { AgentThreadEntry::UserMessage(..) => return false, AgentThreadEntry::AssistantMessage(..) + | AgentThreadEntry::SessionMessage(_) | AgentThreadEntry::ContextCompaction(_) | AgentThreadEntry::Elicitation(_) => continue, AgentThreadEntry::ToolCall(..) => return true, @@ -4783,6 +4826,47 @@ impl AcpThread { cx, ); } + acp_v1::SessionUpdate::SessionMessage(message) => { + let content = match message.content { + MaybeUndefined::Undefined => MaybeUndefined::Undefined, + MaybeUndefined::Null => MaybeUndefined::Null, + MaybeUndefined::Value(blocks) => MaybeUndefined::Value( + blocks + .into_iter() + .map(content::from_v1) + .collect::>>() + .map_err(acp_v1::Error::from)?, + ), + }; + self.upsert_session_message_inner( + acp_v2::SessionMessage::new(message.message_id.0) + .sender_session_id( + message + .sender_session_id + .map(|id| acp_v2::SessionId::new(id.0)), + ) + .recipient_session_id( + message + .recipient_session_id + .map(|id| acp_v2::SessionId::new(id.0)), + ) + .content(content) + .meta(message.meta), + MetadataUpdate::V1, + cx, + ) + .map_err(acp_v1::Error::from)?; + } + acp_v1::SessionUpdate::SessionMessageChunk(chunk) => { + self.append_session_message_chunk( + acp_v2::SessionMessageChunk::new( + chunk.message_id.0, + content::from_v1(chunk.content).map_err(acp_v1::Error::from)?, + ), + cx, + ) + .map_err(acp_v1::Error::from)?; + } _ => {} } Ok(()) @@ -4797,7 +4881,7 @@ impl AcpThread { MessageKind::User, update.message_id, update.content, - update.meta, + MetadataUpdate::V2(update.meta), cx, ) } @@ -4811,7 +4895,7 @@ impl AcpThread { MessageKind::Assistant, update.message_id, update.content, - update.meta, + MetadataUpdate::V2(update.meta), cx, ) } @@ -4825,21 +4909,114 @@ impl AcpThread { MessageKind::Thought, update.message_id, update.content, - update.meta, + MetadataUpdate::V2(update.meta), cx, ) } + pub fn upsert_session_message( + &mut self, + update: acp_v2::SessionMessage, + cx: &mut Context, + ) -> Result<()> { + self.upsert_session_message_inner(update, MetadataUpdate::V2, cx) + } + + fn upsert_session_message_inner( + &mut self, + update: acp_v2::SessionMessage, + metadata: fn(MaybeUndefined) -> MetadataUpdate, + cx: &mut Context, + ) -> Result<()> { + let previous_entry_count = self.entries.len(); + let location = self.session_message_location( + update.message_id, + update.sender_session_id, + update.recipient_session_id, + cx, + )?; + self.replace_message_content( + location, + MessageKind::Session, + update.content, + metadata(update.meta), + previous_entry_count, + cx, + ) + } + + pub fn append_session_message_chunk( + &mut self, + chunk: acp_v2::SessionMessageChunk, + cx: &mut Context, + ) -> Result<()> { + // A chunk carries only content: its metadata does not patch the message's, and the + // RFD keeps a message's participants on `session_message`, so the participant fields + // that this schema version still has on chunks are ignored. + let previous_entry_count = self.entries.len(); + let location = self.keyed_message_location(MessageKind::Session, chunk.message_id, cx)?; + self.append_message_content( + location, + MessageKind::Session, + chunk.content, + previous_entry_count, + cx, + ) + } + + /// Participants that an update omits keep their earlier value, and a known participant + /// cannot change. + fn session_message_location( + &mut self, + id: acp_v2::MessageId, + sender: Option, + recipient: Option, + cx: &mut Context, + ) -> Result { + let location = self.keyed_message_location(MessageKind::Session, id, cx)?; + let Some(AgentThreadEntry::SessionMessage(message)) = + self.entries.get_mut(location.entry_index()) + else { + anyhow::bail!("session message disappeared during update"); + }; + for (stored, reported) in [ + (&mut message.sender_session_id, sender), + (&mut message.recipient_session_id, recipient), + ] { + let Some(reported) = reported else { + continue; + }; + anyhow::ensure!( + stored.as_ref().is_none_or(|stored| stored == &reported), + "Session message participants cannot change" + ); + *stored = Some(reported); + } + Ok(location) + } + fn update_keyed_message( &mut self, kind: MessageKind, id: acp_v2::MessageId, content: MaybeUndefined>, - meta: MaybeUndefined, + meta: MetadataUpdate, cx: &mut Context, ) -> Result<()> { let previous_entry_count = self.entries.len(); let location = self.keyed_message_location(kind, id, cx)?; + self.replace_message_content(location, kind, content, meta, previous_entry_count, cx) + } + + fn replace_message_content( + &mut self, + location: MessageLocation, + kind: MessageKind, + content: MaybeUndefined>, + meta: MetadataUpdate, + previous_entry_count: usize, + cx: &mut Context, + ) -> Result<()> { if !content.is_undefined() && self .streaming_text_buffer @@ -4868,7 +5045,7 @@ impl AcpThread { message_content.replace(replacement, &language_registry, path_style, cx); } } - MetadataUpdate::V2(meta).apply(message_meta); + meta.apply(message_meta); self.emit_message_update(location, previous_entry_count, cx); Ok(()) } @@ -4887,6 +5064,17 @@ impl AcpThread { } = chunk; let previous_entry_count = self.entries.len(); let location = self.keyed_message_location(kind, message_id, cx)?; + self.append_message_content(location, kind, content, previous_entry_count, cx) + } + + fn append_message_content( + &mut self, + location: MessageLocation, + kind: MessageKind, + content: acp_v2::ContentBlock, + previous_entry_count: usize, + cx: &mut Context, + ) -> Result<()> { let content = match content { acp_v2::ContentBlock::Text(text) => { let (content, _) = location @@ -4955,6 +5143,11 @@ impl AcpThread { { Some(MessageLocation::User { entry_index }) } + AgentThreadEntry::SessionMessage(message) + if kind == MessageKind::Session && message.identity == identity => + { + Some(MessageLocation::Session { entry_index }) + } AgentThreadEntry::AssistantMessage(message) => message .chunks .iter() @@ -4988,6 +5181,17 @@ impl AcpThread { })); Ok(MessageLocation::User { entry_index }) } + MessageKind::Session => { + self.entries + .push(AgentThreadEntry::SessionMessage(SessionMessage { + identity, + sender_session_id: None, + recipient_session_id: None, + meta: None, + content: MessageContent::default(), + })); + Ok(MessageLocation::Session { entry_index }) + } MessageKind::Assistant | MessageKind::Thought => { let chunk = if kind == MessageKind::Thought { AssistantMessageChunk::Thought { @@ -11318,6 +11522,9 @@ mod tests { AgentThreadEntry::UserMessage(message) => { (&message.identity, &message.content, &message.meta) } + AgentThreadEntry::SessionMessage(message) => { + (&message.identity, &message.content, &message.meta) + } AgentThreadEntry::AssistantMessage(message) => { let [chunk] = message.chunks.as_slice() else { panic!("expected one assistant chunk"); @@ -11339,6 +11546,23 @@ mod tests { } } + /// Session messages take chunks through their own API, which also records participants. + fn append_keyed_chunk( + thread: &mut AcpThread, + kind: MessageKind, + chunk: acp_v2::ContentChunk, + cx: &mut Context, + ) -> Result<()> { + if kind == MessageKind::Session { + thread.append_session_message_chunk( + acp_v2::SessionMessageChunk::new(chunk.message_id, chunk.content).meta(chunk.meta), + cx, + ) + } else { + thread.append_message_chunk(kind, chunk, cx) + } + } + #[gpui::test] async fn test_unsupported_legacy_prompt_preserves_running_turn(cx: &mut TestAppContext) { init_test(cx); @@ -13454,6 +13678,7 @@ mod tests { MessageKind::User, MessageKind::Assistant, MessageKind::Thought, + MessageKind::Session, ] { let thread = new_test_thread(cx).await; let original = json!([{"type": "text", "text": "original", "_meta": {"block": true}}]); @@ -13520,6 +13745,10 @@ mod tests { serde_json::from_value(patch).expect("thought patch"), cx, ), + MessageKind::Session => thread.upsert_session_message( + serde_json::from_value(patch).expect("session message patch"), + cx, + ), } .expect("apply patch"); let (identity, content, meta) = only_keyed_message(thread); @@ -13541,14 +13770,14 @@ mod tests { acp_v2::TextContent::new("chunk") .meta(acp_v2::Meta::from_iter([("block".into(), json!(true))])), ); - thread - .append_message_chunk( - kind, - acp_v2::ContentChunk::new(block.clone(), "patch") - .meta(acp_v2::Meta::from_iter([("envelope".into(), json!(true))])), - cx, - ) - .expect("append scoped metadata"); + append_keyed_chunk( + thread, + kind, + acp_v2::ContentChunk::new(block.clone(), "patch") + .meta(acp_v2::Meta::from_iter([("envelope".into(), json!(true))])), + cx, + ) + .expect("append scoped metadata"); let (_, content, meta) = only_keyed_message(thread); assert_eq!(content.source_blocks(), &[block]); assert_eq!( @@ -13559,6 +13788,108 @@ mod tests { } } + #[gpui::test] + async fn test_session_messages_keep_participants_and_convert_from_v1(cx: &mut TestAppContext) { + init_test(cx); + let thread = new_test_thread(cx).await; + thread.update(cx, |thread, cx| { + thread + .append_session_message_chunk( + acp_v2::SessionMessageChunk::new("task", "Start by ".into()), + cx, + ) + .expect("a message can start with a chunk and no participants"); + thread + .upsert_session_message( + acp_v2::SessionMessage::new("task") + .sender_session_id(acp_v2::SessionId::new("parent")) + .recipient_session_id(acp_v2::SessionId::new("child")), + cx, + ) + .expect("participants can arrive later"); + thread + .append_session_message_chunk( + acp_v2::SessionMessageChunk::new("task", "reproducing".into()) + .sender_session_id(acp_v2::SessionId::new("other")), + cx, + ) + .expect("a chunk's participant fields are ignored"); + let error = thread + .upsert_session_message( + acp_v2::SessionMessage::new("task") + .sender_session_id(acp_v2::SessionId::new("other")), + cx, + ) + .expect_err("a known participant cannot change"); + assert!(error.to_string().contains("cannot change"), "{error}"); + thread + .upsert_assistant_message( + acp_v2::AgentMessage::new("task").content(vec!["answer".into()]), + cx, + ) + .expect("assistant messages have their own ID space"); + + let [ + AgentThreadEntry::SessionMessage(message), + AgentThreadEntry::AssistantMessage(_), + ] = thread.entries() + else { + panic!("expected a session message, then an assistant message"); + }; + assert_eq!(message.identity, MessageIdentity::Keyed("task".into())); + assert_eq!(message.sender_session_id, Some("parent".into())); + assert_eq!(message.recipient_session_id, Some("child".into())); + assert_eq!( + message.content.source_blocks(), + &["Start by ".into(), "reproducing".into()] + ); + }); + + // v1 replaces message metadata where v2 patches it by key. + let thread = new_test_thread(cx).await; + thread.update(cx, |thread, cx| { + for update in [ + json!({ + "sessionUpdate": "session_message", + "messageId": "reply", + "senderSessionId": "child", + "content": [{"type": "text", "text": "Done"}], + "_meta": {"first": true}, + }), + json!({ + "sessionUpdate": "session_message", + "messageId": "reply", + "recipientSessionId": "parent", + "_meta": {"second": true}, + }), + json!({ + "sessionUpdate": "session_message_chunk", + "messageId": "reply", + "senderSessionId": "other", + "content": {"type": "text", "text": " now"}, + "_meta": {"chunk": true}, + }), + ] { + thread + .handle_session_update(serde_json::from_value(update).expect("v1 update"), cx) + .expect("v1 session message"); + } + let [AgentThreadEntry::SessionMessage(message)] = thread.entries() else { + panic!("expected one session message"); + }; + assert_eq!(message.sender_session_id, Some("child".into())); + assert_eq!(message.recipient_session_id, Some("parent".into())); + assert_eq!( + message.meta, + Some(acp_v2::Meta::from_iter([("second".into(), json!(true))])) + ); + assert_eq!( + message.content.source_blocks(), + &["Done".into(), " now".into()] + ); + }); + } + #[gpui::test] async fn test_v2_entity_metadata_patches_by_key(cx: &mut TestAppContext) { init_test(cx); @@ -13567,6 +13898,7 @@ mod tests { MessageKind::User, MessageKind::Assistant, MessageKind::Thought, + MessageKind::Session, ] { messages.push((kind, new_test_thread(cx).await)); } @@ -13633,19 +13965,25 @@ mod tests { .meta(metadata.clone()), cx, ), + MessageKind::Session => thread.upsert_session_message( + acp_v2::SessionMessage::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"); + append_keyed_chunk( + thread, + *kind, + acp_v2::ContentChunk::new("chunk".into(), "metadata") + .meta(snapshot_meta.clone()), + cx, + ) + .expect("message chunk"); assert_eq!(only_keyed_message(thread).2, &expected); }); } diff --git a/crates/agent_servers/src/acp/session_updates.rs b/crates/agent_servers/src/acp/session_updates.rs index cc2bdf06b4d..4113e177041 100644 --- a/crates/agent_servers/src/acp/session_updates.rs +++ b/crates/agent_servers/src/acp/session_updates.rs @@ -154,6 +154,8 @@ pub enum InboundSessionUpdate { UserMessage(acp_v2::UserMessage), AgentMessage(acp_v2::AgentMessage), AgentThought(acp_v2::AgentThought), + SessionMessage(acp_v2::SessionMessage), + SessionMessageChunk(acp_v2::SessionMessageChunk), UserMessageChunk(acp_v2::ContentChunk), AgentMessageChunk(acp_v2::ContentChunk), AgentThoughtChunk(acp_v2::ContentChunk), @@ -201,6 +203,12 @@ impl TryFrom for InboundSessionNotification { acp_v2::SessionUpdate::AgentThought(thought) => { InboundSessionUpdate::AgentThought(thought) } + acp_v2::SessionUpdate::SessionMessage(message) => { + InboundSessionUpdate::SessionMessage(message) + } + acp_v2::SessionUpdate::SessionMessageChunk(chunk) => { + InboundSessionUpdate::SessionMessageChunk(chunk) + } acp_v2::SessionUpdate::UserMessageChunk(chunk) => { InboundSessionUpdate::UserMessageChunk(chunk) } @@ -280,6 +288,12 @@ impl InboundSessionNotification { thread.upsert_assistant_message(message, cx) } InboundSessionUpdate::AgentThought(thought) => thread.upsert_thought(thought, cx), + InboundSessionUpdate::SessionMessage(message) => { + thread.upsert_session_message(message, cx) + } + InboundSessionUpdate::SessionMessageChunk(chunk) => { + thread.append_session_message_chunk(chunk, cx) + } InboundSessionUpdate::UserMessageChunk(chunk) => { thread.append_message_chunk(MessageKind::User, chunk, cx) } diff --git a/crates/agent_servers/src/acp/v1.rs b/crates/agent_servers/src/acp/v1.rs index 9e8f7386633..670a81f39b4 100644 --- a/crates/agent_servers/src/acp/v1.rs +++ b/crates/agent_servers/src/acp/v1.rs @@ -8007,20 +8007,36 @@ exit 7 let parent_id = parent_session_id.0.to_string(); let unadvertised = context_for(false, cx); - handle_session_notification( - acp::SessionNotification::new( - parent_id.clone(), - acp::SessionUpdate::SubagentUpdate(acp::SubagentUpdate::new("child")), - ), - &mut cx.to_async(), - &unadvertised, - ); + let delegation = || { + acp::SessionMessage::new("delegation") + .sender_session_id(acp::SessionId::new(parent_id.clone())) + .recipient_session_id(acp::SessionId::new("child")) + .content(vec!["Investigate".into()]) + }; + for update in [ + acp::SessionUpdate::SubagentUpdate(acp::SubagentUpdate::new("child")), + acp::SessionUpdate::SessionMessage(delegation()), + acp::SessionUpdate::SessionMessageChunk(acp::SessionMessageChunk::new( + "delegation", + " more".into(), + )), + ] { + handle_session_notification( + acp::SessionNotification::new(parent_id.clone(), update), + &mut cx.to_async(), + &unadvertised, + ); + } parent.read_with(cx, |parent, _| { assert_eq!( parent.subagents().count(), 0, "without the advertised capability, a v1 agent's subagent updates are ignored" ); + assert!( + parent.entries().is_empty(), + "and so are its session messages" + ); }); assert!( !sessions @@ -8055,6 +8071,20 @@ exit 7 acp::SessionUpdate::AgentMessageChunk(acp::ContentChunk::new("Working".into())), cx, ); + notify( + &parent_id, + acp::SessionUpdate::SessionMessage(delegation()), + cx, + ); + parent.read_with(cx, |parent, _| { + assert!( + matches!( + parent.entries(), + [acp_thread::AgentThreadEntry::SessionMessage(_)] + ), + "with the capability, session messages are applied" + ); + }); let child = parent .read_with(cx, |parent, _| parent.subagent(&"child".into()).cloned()) .expect("the parent owns the announced subagent"); @@ -8791,6 +8821,7 @@ exit 7 .map(|entry| match entry { acp_thread::AgentThreadEntry::UserMessage(_) => "user", acp_thread::AgentThreadEntry::AssistantMessage(_) => "assistant", + acp_thread::AgentThreadEntry::SessionMessage(_) => "session_message", acp_thread::AgentThreadEntry::ToolCall(_) => "tool_call", acp_thread::AgentThreadEntry::Elicitation(_) => "elicitation", acp_thread::AgentThreadEntry::ContextCompaction(_) => "compaction", @@ -9791,13 +9822,20 @@ fn handle_session_notification( return; }; + if matches!( + notification.update, + acp::SessionUpdate::SubagentUpdate(_) + | acp::SessionUpdate::SessionMessage(_) + | acp::SessionUpdate::SessionMessageChunk(_) + ) && !ctx.accepts_subagent_updates + { + log::warn!( + "Ignoring a subagents update for {session_id:?}: Zed did not advertise the subagents capability" + ); + return; + } + if let acp::SessionUpdate::SubagentUpdate(update) = notification.update { - if !ctx.accepts_subagent_updates { - log::warn!( - "Ignoring subagent update for {session_id:?}: Zed did not advertise the subagents capability" - ); - return; - } if let Err(error) = cx.update(|cx| apply_v1_subagent_update(&strong_thread, update, &ctx.sessions, cx)) { diff --git a/crates/agent_servers/src/acp/v2.rs b/crates/agent_servers/src/acp/v2.rs index e6c9929532a..bb5a5e6be82 100644 --- a/crates/agent_servers/src/acp/v2.rs +++ b/crates/agent_servers/src/acp/v2.rs @@ -2374,6 +2374,94 @@ mod tests { }); } + #[gpui::test] + async fn v2_session_messages_reach_both_transcripts(cx: &mut TestAppContext) { + let harness = SessionHarness::new(session_capabilities(), vec![], vec![], cx).await; + let parent = harness.thread(cx).await; + harness.send_update( + "session", + acp::SessionUpdate::SubagentUpdate(acp::SubagentUpdate::new("child")), + ); + let message = acp::SessionMessage::new("delegation") + .sender_session_id(acp::SessionId::new("session")) + .recipient_session_id(acp::SessionId::new("child")) + .content(vec!["Investigate the failure".into()]); + harness.send_update( + "session", + acp::SessionUpdate::SessionMessage(message.clone()), + ); + harness.send_update("child", acp::SessionUpdate::SessionMessage(message)); + harness.send_update( + "child", + acp::SessionUpdate::SessionMessageChunk(acp::SessionMessageChunk::new( + "delegation", + " on Windows".into(), + )), + ); + harness.drain_updates(cx).await; + + let child = parent + .read_with(cx, |parent, _| parent.subagent(&"child".into()).cloned()) + .expect("announced subagent"); + for (thread, expected_blocks) in [ + (&parent, vec!["Investigate the failure".into()]), + ( + &child, + vec!["Investigate the failure".into(), " on Windows".into()], + ), + ] { + thread.read_with(cx, |thread, _| { + let [acp_thread::AgentThreadEntry::SessionMessage(message)] = thread.entries() + else { + panic!("expected one session message in {}", thread.session_id()); + }; + assert_eq!(message.sender_session_id, Some("session".into())); + assert_eq!(message.recipient_session_id, Some("child".into())); + assert_eq!(message.content.source_blocks(), expected_blocks.as_slice()); + }); + } + } + + #[gpui::test] + async fn v2_resume_replay_delivers_subagent_history(cx: &mut TestAppContext) { + let harness = SessionHarness::new(session_capabilities(), vec![], vec![], cx).await; + let loading = harness.reopen(true, cx); + let (_, responder) = bounded(harness.resume_requests.recv(), cx) + .await + .expect("resume"); + harness.send_update( + "saved", + acp::SessionUpdate::SubagentUpdate(acp::SubagentUpdate::new("child")), + ); + harness.send_update( + "child", + acp::SessionUpdate::AgentMessage( + acp::AgentMessage::new("child-history").content(vec!["Replayed".into()]), + ), + ); + let initial = initial_response(); + responder + .respond( + acp::ResumeSessionResponse::new() + .config_options(initial.config_options) + .available_commands(initial.available_commands), + ) + .expect("resumed"); + let parent = bounded(loading, cx).await.expect("resumed parent"); + cx.run_until_parked(); + + let child = parent + .read_with(cx, |parent, _| parent.subagent(&"child".into()).cloned()) + .expect("the replayed announcement creates the subagent"); + child.read_with(cx, |child, _| { + assert_eq!( + child.entries().len(), + 1, + "history replayed before the resume response reaches the subagent" + ); + }); + } + #[gpui::test] async fn v2_subagent_updates_route_and_patch_child_sessions(cx: &mut TestAppContext) { use acp_thread::{ThreadStatus, subagents::SubagentAssociation}; diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs index bc94442fc0d..124299aecc2 100644 --- a/crates/agent_ui/src/conversation_view.rs +++ b/crates/agent_ui/src/conversation_view.rs @@ -20162,6 +20162,146 @@ pub(crate) mod tests { assert_eq!(label(&acp_child, cx), "Parent title"); } + #[test] + fn session_message_side_follows_the_transcripts_own_session() { + use thread_view::{SessionMessageSide, session_message_side}; + + let own = acp_v2::SessionId::new("own"); + let other = acp_v2::SessionId::new("other"); + for (sender, recipient, expected) in [ + ( + Some("own"), + Some("other"), + SessionMessageSide::Outgoing { + recipient: Some(&other), + }, + ), + ( + Some("own"), + None, + SessionMessageSide::Outgoing { recipient: None }, + ), + ( + Some("other"), + Some("own"), + SessionMessageSide::Incoming { + sender: Some(&other), + }, + ), + ( + None, + Some("own"), + SessionMessageSide::Incoming { sender: None }, + ), + ( + Some("other"), + None, + SessionMessageSide::Incoming { + sender: Some(&other), + }, + ), + ( + None, + Some("other"), + SessionMessageSide::Outgoing { + recipient: Some(&other), + }, + ), + (None, None, SessionMessageSide::Unknown), + ] { + let message = acp_thread::SessionMessage { + identity: acp_thread::MessageIdentity::Keyed("message".into()), + sender_session_id: sender.map(acp_v2::SessionId::new), + recipient_session_id: recipient.map(acp_v2::SessionId::new), + meta: None, + content: acp_thread::MessageContent::default(), + }; + assert_eq!( + session_message_side(&message, &own), + expected, + "{sender:?} -> {recipient:?}" + ); + } + } + + #[gpui::test] + async fn test_session_message_participant_opens_its_session(cx: &mut TestAppContext) { + init_test(cx); + let connection = StubAgentConnection::new(); + let (conversation_view, cx) = + setup_conversation_view(StubAgentServer::new(connection.clone()), cx).await; + add_to_workspace_with_size(conversation_view.clone(), true, cx); + let root = + active_thread(&conversation_view, cx).read_with(cx, |view, _| view.thread.clone()); + let root_session_id = root.read_with(cx, |thread, _| thread.session_id().clone()); + let child = conversation_view.update(cx, |view, cx| { + create_test_acp_subagent( + root_session_id.clone(), + "child", + Rc::new(connection.clone()), + view.project.clone(), + cx, + ) + }); + child.update(cx, |child, cx| { + child + .update_subagent_association( + &acp_v2::SubagentUpdate::new("child").title("Investigator"), + cx, + ) + .expect("ACP subagent") + }); + // Each ACP notification is applied in its own update, as here. + root.update(cx, |root, cx| root.register_subagent(child.clone(), cx)); + root.update(cx, |root, cx| { + root.upsert_session_message( + acp_v2::SessionMessage::new("to-child") + .sender_session_id(root_session_id.clone()) + .recipient_session_id(acp_v2::SessionId::new("child")) + .content(vec!["Investigate the failure".into()]), + cx, + ) + }) + .expect("outgoing message"); + root.update(cx, |root, cx| { + root.upsert_session_message( + acp_v2::SessionMessage::new("from-unknown") + .sender_session_id(acp_v2::SessionId::new("unknown")) + .recipient_session_id(root_session_id.clone()) + .content(vec!["Hello".into()]), + cx, + ) + }) + .expect("incoming message"); + cx.run_until_parked(); + + active_thread(&conversation_view, cx).read_with(cx, |view, cx| { + for (session_id, expected) in [ + ("child", Some("Investigator")), + (root_session_id.0.as_ref(), Some("Main Agent")), + ("unknown", None), + ] { + assert_eq!( + view.session_participant_label(&acp_v2::SessionId::new(session_id), cx), + expected.map(SharedString::from), + "{session_id}" + ); + } + }); + assert!( + cx.debug_bounds("session-message-participant-1").is_none(), + "an unknown participant is not a link" + ); + let link = cx + .debug_bounds("session-message-participant-0") + .expect("the recipient links to its session"); + cx.simulate_click(link.center(), gpui::Modifiers::default()); + cx.run_until_parked(); + let active_session_id = active_thread(&conversation_view, cx) + .read_with(cx, |view, cx| view.thread.read(cx).session_id().clone()); + assert_eq!(active_session_id, acp_v2::SessionId::new("child")); + } + #[gpui::test] async fn test_release_policy_does_not_disable_explicit_close(cx: &mut TestAppContext) { init_test(cx); 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 3f7175fec1e..0a1aa6a42c4 100644 --- a/crates/agent_ui/src/conversation_view/thread_search_bar.rs +++ b/crates/agent_ui/src/conversation_view/thread_search_bar.rs @@ -951,6 +951,9 @@ fn collect_markdowns( let mut out = Vec::new(); match entry { AgentThreadEntry::UserMessage(_) => {} + AgentThreadEntry::SessionMessage(message) => { + out.extend(message.content.markdowns().cloned()) + } AgentThreadEntry::AssistantMessage(message) => { for (chunk_ix, chunk) in message.chunks.iter().enumerate() { match chunk { diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs index 385cfabe5b2..af8d9075ccd 100644 --- a/crates/agent_ui/src/conversation_view/thread_view.rs +++ b/crates/agent_ui/src/conversation_view/thread_view.rs @@ -58,6 +58,38 @@ use super::elicitation::{ use super::subagent_card::{SubagentCardState, SubagentStatus}; use super::*; +/// Which side of a session message a transcript shows, and the other participant when it +/// is known. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(super) enum SessionMessageSide<'a> { + Outgoing { + recipient: Option<&'a acp_v2::SessionId>, + }, + Incoming { + sender: Option<&'a acp_v2::SessionId>, + }, + Unknown, +} + +/// The transcript's own session is always one participant, so a single known participant +/// that is another session also tells the direction. +pub(super) fn session_message_side<'a>( + message: &'a acp_thread::SessionMessage, + own_session_id: &acp_v2::SessionId, +) -> SessionMessageSide<'a> { + let sender = message.sender_session_id.as_ref(); + let recipient = message.recipient_session_id.as_ref(); + if sender == Some(own_session_id) { + SessionMessageSide::Outgoing { recipient } + } else if recipient == Some(own_session_id) || sender.is_some() { + SessionMessageSide::Incoming { sender } + } else if recipient.is_some() { + SessionMessageSide::Outgoing { recipient } + } else { + SessionMessageSide::Unknown + } +} + /// How a parent's view names a subagent. An ACP parent's own title for the subagent /// describes it in that view, so it wins over the subagent's title for itself. pub(super) fn subagent_label(thread: &AcpThread) -> SharedString { @@ -7535,6 +7567,19 @@ impl ThreadView { AgentThreadEntry::ContextCompaction(compaction) => { self.render_context_compaction(entry_ix, compaction, window, cx) } + AgentThreadEntry::SessionMessage(message) => { + let session_message = self.render_session_message(entry_ix, message, window, cx); + if let Some(handle) = self + .entry_view_state + .read(cx) + .entry(entry_ix) + .and_then(|entry| entry.focus_handle(cx)) + { + session_message.track_focus(&handle).into_any() + } else { + session_message.into_any() + } + } }; let is_subagent_output = self.is_subagent() @@ -8851,6 +8896,7 @@ impl ThreadView { AgentThreadEntry::ToolCall(_) | AgentThreadEntry::Elicitation(_) | AgentThreadEntry::AssistantMessage(_) + | AgentThreadEntry::SessionMessage(_) | AgentThreadEntry::ContextCompaction(_) => {} } } @@ -8858,6 +8904,90 @@ impl ThreadView { has_running_terminal_call } + fn render_session_message( + &self, + entry_ix: usize, + message: &acp_thread::SessionMessage, + window: &Window, + cx: &Context, + ) -> Div { + let own_session_id = self.thread.read(cx).session_id().clone(); + let (icon, direction, participant) = match session_message_side(message, &own_session_id) { + SessionMessageSide::Outgoing { recipient } => (IconName::Send, "To", recipient), + SessionMessageSide::Incoming { sender } => (IconName::Envelope, "From", sender), + SessionMessageSide::Unknown => (IconName::Envelope, "Message between sessions", None), + }; + let participant = participant.map(|session_id| { + match self.session_participant_label(session_id, cx) { + Some(label) => div() + .debug_selector(move || format!("session-message-participant-{entry_ix}")) + .child( + Button::new(("session-message-participant", entry_ix), label) + .label_size(LabelSize::Small) + .tooltip(Tooltip::text("Open Session")) + .on_click(cx.listener({ + let session_id = session_id.clone(); + move |this, _, window, cx| { + this.server_view + .update(cx, |view, cx| { + view.navigate_to_thread(session_id.clone(), window, cx) + }) + .log_err(); + } + })), + ) + .into_any_element(), + // The RFD allows messages naming a session this conversation never learned about. + None => Label::new("Unavailable Session") + .size(LabelSize::Small) + .color(Color::Muted) + .into_any_element(), + } + }); + + v_flex() + .px_5() + .py_1p5() + .w_full() + .gap_1p5() + .text_ui(cx) + .child( + h_flex() + .gap_1p5() + .child(Icon::new(icon).size(IconSize::Small).color(Color::Muted)) + .child( + Label::new(direction) + .size(LabelSize::Small) + .color(Color::Muted), + ) + .children(participant), + ) + .child( + div() + .pl_3() + .border_l_2() + .border_color(cx.theme().colors().border) + .child(self.render_message_content(entry_ix, 0, &message.content, window, cx)), + ) + } + + /// How this conversation names another of its sessions, or `None` when it has no thread + /// for that session. + pub(super) fn session_participant_label( + &self, + session_id: &acp_v2::SessionId, + cx: &App, + ) -> Option { + let server_view = self.server_view.upgrade()?; + let thread_view = server_view.read(cx).thread_view(session_id)?; + let thread = thread_view.read(cx).thread.read(cx); + Some(if thread.parent_session_id().is_none() { + "Main Agent".into() + } else { + subagent_label(thread) + }) + } + fn render_collapsible_command( &self, group: SharedString, diff --git a/crates/agent_ui/src/entry_view_state.rs b/crates/agent_ui/src/entry_view_state.rs index f36f15e9b96..143ee2bbc0d 100644 --- a/crates/agent_ui/src/entry_view_state.rs +++ b/crates/agent_ui/src/entry_view_state.rs @@ -549,6 +549,16 @@ impl EntryViewState { ); } } + AgentThreadEntry::SessionMessage(_) => { + if !matches!(self.entries.get(index), Some(Entry::SessionMessage { .. })) { + self.set_entry( + index, + Entry::SessionMessage { + focus_handle: cx.focus_handle(), + }, + ); + } + } AgentThreadEntry::AssistantMessage(message) => { let entry = if let Some(Entry::AssistantMessage(entry)) = self.entries.get_mut(index) @@ -620,6 +630,7 @@ impl EntryViewState { match entry { Entry::UserMessage { .. } | Entry::AssistantMessage { .. } + | Entry::SessionMessage { .. } | Entry::Elicitation { .. } | Entry::ContextCompaction => {} Entry::ToolCall(ToolCallEntry { content, .. }) => { @@ -698,6 +709,9 @@ pub enum Entry { synced_source_version: acp_thread::MessageContentVersion, }, AssistantMessage(AssistantMessageEntry), + SessionMessage { + focus_handle: FocusHandle, + }, ToolCall(ToolCallEntry), Elicitation { focus_handle: FocusHandle, @@ -710,6 +724,7 @@ impl Entry { match self { Self::UserMessage { editor, .. } => Some(editor.read(cx).focus_handle(cx)), Self::AssistantMessage(message) => Some(message.focus_handle.clone()), + Self::SessionMessage { focus_handle } => Some(focus_handle.clone()), Self::ToolCall(tool_call) => Some(tool_call.focus_handle.clone()), Self::Elicitation { focus_handle } => Some(focus_handle.clone()), Self::ContextCompaction => None, @@ -720,6 +735,7 @@ impl Entry { match self { Self::UserMessage { editor, .. } => Some(editor), Self::AssistantMessage(_) + | Self::SessionMessage { .. } | Self::ToolCall(_) | Self::Elicitation { .. } | Self::ContextCompaction => None, @@ -757,6 +773,7 @@ impl Entry { match self { Self::AssistantMessage(message) => message.scroll_handle_for_chunk(chunk_ix), Self::UserMessage { .. } + | Self::SessionMessage { .. } | Self::ToolCall(_) | Self::Elicitation { .. } | Self::ContextCompaction => None, @@ -776,6 +793,7 @@ impl Entry { Self::ToolCall(ToolCallEntry { content, .. }) => !content.is_empty(), Self::UserMessage { .. } | Self::AssistantMessage(_) + | Self::SessionMessage { .. } | Self::Elicitation { .. } | Self::ContextCompaction => false, } @@ -793,6 +811,7 @@ impl Focusable for Entry { match self { Self::UserMessage { editor, .. } => editor.read(cx).focus_handle(cx), Self::AssistantMessage(message) => message.focus_handle.clone(), + Self::SessionMessage { focus_handle } => focus_handle.clone(), Self::ToolCall(tool_call) => tool_call.focus_handle.clone(), Self::Elicitation { focus_handle } => focus_handle.clone(), Self::ContextCompaction => cx.focus_handle(),