mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-19 06:59:22 +01:00
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:
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
{
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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(),
|
||||
|
||||
Reference in New Issue
Block a user