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 <recipient>" or "From <sender>". 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
This commit is contained in:
Ben Brandt
2026-10-23 12:43:26 +00:00
committed by GitHub
parent 91d3b962ae
commit e96ffb0fd3
8 changed files with 806 additions and 36 deletions
+360 -22
View File
@@ -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<acp_v2::SessionId>,
pub recipient_session_id: Option<acp_v2::SessionId>,
pub meta: Option<acp_v2::Meta>,
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<AssistantMessageChunk>,
@@ -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::<Result<Vec<_>>>()
.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<Self>,
) -> Result<()> {
self.upsert_session_message_inner(update, MetadataUpdate::V2, cx)
}
fn upsert_session_message_inner(
&mut self,
update: acp_v2::SessionMessage,
metadata: fn(MaybeUndefined<acp_v2::Meta>) -> MetadataUpdate,
cx: &mut Context<Self>,
) -> 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<Self>,
) -> 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<acp_v2::SessionId>,
recipient: Option<acp_v2::SessionId>,
cx: &mut Context<Self>,
) -> Result<MessageLocation> {
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<Vec<acp_v2::ContentBlock>>,
meta: MaybeUndefined<acp_v2::Meta>,
meta: MetadataUpdate,
cx: &mut Context<Self>,
) -> 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<Vec<acp_v2::ContentBlock>>,
meta: MetadataUpdate,
previous_entry_count: usize,
cx: &mut Context<Self>,
) -> 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<Self>,
) -> 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<AcpThread>,
) -> 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);
});
}
@@ -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<acp_v2::UpdateSessionNotification> 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)
}
+52 -14
View File
@@ -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))
{
+88
View File
@@ -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};
+140
View File
@@ -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);
@@ -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 {
@@ -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<Self>,
) -> 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<SharedString> {
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,
+19
View File
@@ -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(),