mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
Show subagents and their status in the TUI sidebar chooser (#62149)
## Why The sidebar chooser lists side chats and files. Adding subagents lets users check their progress and switch to their conversations from the same menu. ## What changed - Add a `Subagents` section for the main conversation's spawn tree. Show each agent's name and status, and let users select an agent to switch to its conversation. - Keep explicit outcomes such as `Completed`, `Stopped`, and `Failed` visible through idle or unloaded updates. Restore outcomes from saved activity and give live updates precedence over in-flight discovery. ## Testing Add wide and narrow chooser snapshots and regression tests for outcome retention and discovery updates that race with live notifications. GitOrigin-RevId: 93092e6bd5c59724f69f52785e3c22aa2c1313d8
This commit is contained in:
@@ -136,6 +136,7 @@ impl App {
|
||||
let Ok(thread_id) = ThreadId::from_string(&thread.id) else {
|
||||
continue;
|
||||
};
|
||||
let sidebar_agent = self.register_sidebar_agent(root, thread_id);
|
||||
if !completion.visibility_changed_threads.contains(&thread_id) {
|
||||
self.update_agent_picker_thread_visibility(
|
||||
thread_id,
|
||||
@@ -168,6 +169,10 @@ impl App {
|
||||
if !live && update_liveness {
|
||||
self.agent_navigation.set_running(thread_id, is_running);
|
||||
}
|
||||
if sidebar_agent && !live && (is_running || thread.status == ThreadStatus::SystemError)
|
||||
{
|
||||
self.seed_discovered_sidebar_agent(root, thread_id, &thread.status);
|
||||
}
|
||||
}
|
||||
for thread_id in refresh.archived_thread_ids {
|
||||
if !completion.visibility_changed_threads.contains(&thread_id) {
|
||||
|
||||
@@ -262,6 +262,7 @@ impl App {
|
||||
}
|
||||
}
|
||||
|
||||
self.observe_sidebar_agent_event(¬ification);
|
||||
if let ServerNotification::ThreadStatusChanged(status) = ¬ification {
|
||||
let _ = self.dynamic_tool_status_updates.send(status.clone());
|
||||
}
|
||||
|
||||
@@ -3579,6 +3579,11 @@ impl App {
|
||||
AppEvent::OpenAgentPicker => {
|
||||
self.open_agent_picker(app_server).await;
|
||||
}
|
||||
AppEvent::DiscoverSidebarAgents(root) => {
|
||||
if self.primary_thread_id == Some(root) && !self.reconnect.offline {
|
||||
self.refresh_agent_picker_threads(app_server, root);
|
||||
}
|
||||
}
|
||||
AppEvent::AgentPickerThreadsLoaded {
|
||||
primary_thread_id,
|
||||
request_id,
|
||||
|
||||
@@ -112,7 +112,7 @@ fn thread_spawn_agent_path(source: &SessionSource) -> Option<String> {
|
||||
}
|
||||
}
|
||||
|
||||
fn thread_spawn_parent_thread_id(source: &SessionSource) -> Option<ThreadId> {
|
||||
pub(super) fn thread_spawn_parent_thread_id(source: &SessionSource) -> Option<ThreadId> {
|
||||
match source {
|
||||
SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
||||
parent_thread_id, ..
|
||||
|
||||
@@ -263,6 +263,11 @@ impl App {
|
||||
{
|
||||
pane.close = None;
|
||||
}
|
||||
if let Some(pane) = self.sidebars.get_mut(&self.sidebar_parent())
|
||||
&& pane.visible_content().is_some()
|
||||
{
|
||||
pane.sync_agent_rows(&self.agent_navigation);
|
||||
}
|
||||
let layout = sidebar::paint_layout(self, tui, screen_size.into());
|
||||
let displayed = self.current_displayed_thread_id();
|
||||
let chat = match displayed.and_then(|id| self.side_pair_key(id)) {
|
||||
|
||||
@@ -565,6 +565,11 @@ impl App {
|
||||
self.agent_navigation.mark_stopped(id);
|
||||
}
|
||||
if self.primary_thread_id == Some(id) {
|
||||
self.restore_sidebar_agent_outcomes(
|
||||
id,
|
||||
&started.turns,
|
||||
super::sidebar_subagents::OutcomeReplay::Reconnect,
|
||||
);
|
||||
self.primary_session_configured = Some(started.session.clone());
|
||||
}
|
||||
if started.blocks_direct_input {
|
||||
|
||||
@@ -1822,6 +1822,7 @@ impl App {
|
||||
|
||||
let mut refreshed_thread_ids = HashSet::new();
|
||||
for thread in find_loaded_subagent_threads_for_primary(threads, primary_thread_id) {
|
||||
self.register_sidebar_agent(primary_thread_id, thread.thread_id);
|
||||
let agent_path = thread.agent_path;
|
||||
let has_live_channel = self
|
||||
.thread_event_channels
|
||||
|
||||
@@ -403,6 +403,7 @@ impl App {
|
||||
&& list_action != ListAction::Cancel
|
||||
&& pane.creation.is_none()
|
||||
&& pane.chat_tabs().files.is_empty()
|
||||
&& pane.chat_tabs().agents.is_empty()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
@@ -451,7 +452,9 @@ impl App {
|
||||
if let ChooserAction::Open(index) = action
|
||||
&& new_chat == sidebar_chooser::NewChatState::WaitingForMainMessage
|
||||
&& self.sidebar().is_some_and(|pane| {
|
||||
pane.creation.is_none() && pane.chat_tabs().file(index).is_none()
|
||||
pane.creation.is_none()
|
||||
&& pane.chat_tabs().file(index).is_none()
|
||||
&& pane.chat_tabs().agent(index).is_none()
|
||||
})
|
||||
{
|
||||
return true;
|
||||
@@ -486,6 +489,23 @@ impl App {
|
||||
return true;
|
||||
}
|
||||
let pane = self.sidebar_mut();
|
||||
if let ChooserAction::Open(index) = action
|
||||
&& pane.creation.is_none()
|
||||
&& let Some(agent) = pane.chat_tabs().agent(index).map(|agent| agent.id)
|
||||
{
|
||||
pane.choice = index;
|
||||
if self
|
||||
.agent_navigation
|
||||
.visible_threads()
|
||||
.iter()
|
||||
.any(|(id, _)| *id == agent)
|
||||
&& let Err(error) = Box::pin(self.select_agent_thread(tui, server, agent)).await
|
||||
{
|
||||
self.chat_widget.add_error_message(error.to_string());
|
||||
}
|
||||
self.guard_chooser_key(activation);
|
||||
return true;
|
||||
}
|
||||
if let ChooserAction::Open(index) = action
|
||||
&& pane.creation.is_none()
|
||||
&& pane.chat_tabs().retry_row(index)
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
//! can paint the closing frames and reverse direction if reopened mid-slide.
|
||||
|
||||
use super::App;
|
||||
use super::agent_navigation::AgentNavigationState;
|
||||
use super::pane_motion::PaneMotion;
|
||||
use super::side_pane;
|
||||
use super::side_pane::SidePaneLayout;
|
||||
@@ -65,6 +66,7 @@ impl SideCreation {
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
pub(super) enum ChooserSelection {
|
||||
Agent(ThreadId),
|
||||
New,
|
||||
Chat(ThreadId),
|
||||
Retry,
|
||||
@@ -92,6 +94,7 @@ pub(super) struct SidebarPane {
|
||||
pub(super) focus_document_request: Option<uuid::Uuid>,
|
||||
content: SidebarContent,
|
||||
tabs: Vec<SidebarTab>,
|
||||
pub(super) agents: super::sidebar_subagents::Overview,
|
||||
// The chooser keeps the same order when an attached chat becomes a live tab.
|
||||
choices: Vec<SideChat>,
|
||||
// A snapshot of the visible rows at the last explicit chooser refresh.
|
||||
@@ -204,6 +207,7 @@ impl SidebarPane {
|
||||
opening: self.opening.as_ref(),
|
||||
ids: &self.tabs,
|
||||
choices: &self.choices,
|
||||
agents: &self.agents.rows,
|
||||
latest_prompts: &self.latest_prompts,
|
||||
selected: self.visits.last().copied(),
|
||||
files: self
|
||||
@@ -219,23 +223,59 @@ impl SidebarPane {
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn sync_agent_rows(&mut self, nav: &AgentNavigationState) {
|
||||
let rows = self.agents.chooser_rows(nav);
|
||||
let reordered = self
|
||||
.agents
|
||||
.rows
|
||||
.iter()
|
||||
.map(|agent| agent.id)
|
||||
.ne(rows.iter().map(|agent| agent.id));
|
||||
let selection = self.input_state().choice;
|
||||
self.agents.rows = rows;
|
||||
if reordered {
|
||||
self.restore_choice(selection);
|
||||
self.tabs_revision += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn restore_choice(&mut self, selection: ChooserSelection) {
|
||||
let tabs = self.chat_tabs();
|
||||
let index = match selection {
|
||||
ChooserSelection::New => Some(0),
|
||||
ChooserSelection::Chat(id) => tabs.choice_index(id),
|
||||
ChooserSelection::Agent(id) => tabs.agent_index(id),
|
||||
ChooserSelection::File(offset) => {
|
||||
Some(tabs.file_start() + offset).filter(|&index| tabs.file(index).is_some())
|
||||
}
|
||||
ChooserSelection::Retry => {
|
||||
Some(tabs.choices.len() + 1).filter(|&index| tabs.retry_row(index))
|
||||
}
|
||||
};
|
||||
if let Some(index) = index {
|
||||
self.choice = index;
|
||||
} else {
|
||||
self.reset_choice();
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn set_discovery(&mut self, discovery: Discovery) {
|
||||
let file = self.chat_tabs().file_offset(self.choice);
|
||||
if matches!(discovery, Discovery::Failed(_)) && self.choices.is_empty() {
|
||||
self.choice = 1;
|
||||
}
|
||||
let selection = self.input_state().choice;
|
||||
self.discovery = discovery;
|
||||
if let Some(offset) = file {
|
||||
self.choice = self.chat_tabs().file_start() + offset;
|
||||
if self.choices.is_empty()
|
||||
&& matches!(self.discovery, Discovery::Failed(_))
|
||||
&& selection == ChooserSelection::New
|
||||
{
|
||||
self.choice = 1;
|
||||
} else {
|
||||
self.restore_choice(selection);
|
||||
}
|
||||
self.choice = self.choice.min(self.chat_tabs().choice_count() - 1);
|
||||
self.tabs_revision += 1;
|
||||
}
|
||||
|
||||
pub(super) fn update_saved_chats(&mut self, mut chats: Vec<SideChat>) {
|
||||
let file = self.chat_tabs().file_offset(self.choice);
|
||||
let selection = self.chat_tabs().choice(self.choice);
|
||||
let keep_new = self.choice == 0 && !self.choices.is_empty();
|
||||
let selection = self.input_state().choice;
|
||||
let was_empty = self.choices.is_empty();
|
||||
for chat in &mut self.choices {
|
||||
if !self.tabs.contains(&SidebarTab::Chat(chat.id)) {
|
||||
continue;
|
||||
@@ -254,12 +294,10 @@ impl SidebarPane {
|
||||
self.choices = chats;
|
||||
if reordered {
|
||||
self.tabs_revision += 1;
|
||||
if let Some(offset) = file {
|
||||
self.choice = self.chat_tabs().file_start() + offset;
|
||||
} else if let Some(index) = selection.and_then(|id| self.chat_tabs().choice_index(id)) {
|
||||
self.choice = index;
|
||||
} else if !keep_new {
|
||||
if selection == ChooserSelection::New && was_empty {
|
||||
self.reset_choice();
|
||||
} else {
|
||||
self.restore_choice(selection);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -386,6 +424,8 @@ impl SidebarPane {
|
||||
ChooserSelection::Retry
|
||||
} else if let Some(offset) = tabs.file_offset(self.choice) {
|
||||
ChooserSelection::File(offset)
|
||||
} else if let Some(agent) = tabs.agent(self.choice) {
|
||||
ChooserSelection::Agent(agent.id)
|
||||
} else {
|
||||
ChooserSelection::New
|
||||
};
|
||||
@@ -403,10 +443,9 @@ impl SidebarPane {
|
||||
fn add_tab(&mut self, id: ThreadId) {
|
||||
if !self.tabs.contains(&SidebarTab::Chat(id)) {
|
||||
if self.chat_tabs().choice_index(id).is_none() {
|
||||
if self.chat_tabs().file_offset(self.choice).is_some() {
|
||||
self.choice += 1;
|
||||
}
|
||||
let selection = self.input_state().choice;
|
||||
self.choices.push(id.into());
|
||||
self.restore_choice(selection);
|
||||
}
|
||||
self.tabs.push(SidebarTab::Chat(id));
|
||||
self.tabs_revision += 1;
|
||||
@@ -455,8 +494,9 @@ impl SidebarPane {
|
||||
self.remove_choice(id);
|
||||
}
|
||||
if self.content == SidebarContent::Chat(id) {
|
||||
self.content = match self.selected_chat() {
|
||||
Some(child) => SidebarContent::Chat(child),
|
||||
self.content = match self.recent_tab(/*excluding*/ None) {
|
||||
Some(SidebarTab::Chat(child)) => SidebarContent::Chat(child),
|
||||
Some(SidebarTab::Document(doc)) => SidebarContent::Document(doc),
|
||||
None => {
|
||||
self.hide();
|
||||
self.motion = PaneMotion::default();
|
||||
@@ -475,16 +515,13 @@ impl SidebarPane {
|
||||
self.opening = None;
|
||||
}
|
||||
if let Some(index) = self.chat_tabs().choice_index(id) {
|
||||
let selection = self.input_state().choice;
|
||||
self.choices.remove(index - 1);
|
||||
if index < self.choice {
|
||||
self.choice -= 1;
|
||||
}
|
||||
let last = if self.files.is_some() {
|
||||
self.chat_tabs().choice_count() - 1
|
||||
if selection == ChooserSelection::Chat(id) {
|
||||
self.choice = index.min(self.chat_tabs().choice_count() - 1);
|
||||
} else {
|
||||
self.choices.len()
|
||||
};
|
||||
self.choice = self.choice.min(last);
|
||||
self.restore_choice(selection);
|
||||
}
|
||||
self.tabs_revision += 1;
|
||||
}
|
||||
}
|
||||
@@ -631,10 +668,8 @@ impl App {
|
||||
|
||||
pub(super) fn panel_focus(&self) -> Option<PaneFocus> {
|
||||
let pane = self.sidebar()?;
|
||||
match pane.content {
|
||||
SidebarContent::Chooser | SidebarContent::Document(_) => pane.focus,
|
||||
SidebarContent::Chat(_) => None,
|
||||
}
|
||||
pane.focus
|
||||
.filter(|_| !matches!(pane.content, SidebarContent::Chat(_)))
|
||||
}
|
||||
|
||||
pub(super) fn sidebar_has_focus(&self) -> bool {
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
//! Retain observed subagent outcomes across later idle/unloaded notifications.
|
||||
//! Only explicit work starts clear an outcome; idle alone never implies completion.
|
||||
|
||||
use super::Overview;
|
||||
use codex_app_server_protocol::CollabAgentStatus;
|
||||
use codex_app_server_protocol::CollabAgentTool;
|
||||
use codex_app_server_protocol::ServerNotification;
|
||||
use codex_app_server_protocol::SubAgentActivityKind;
|
||||
use codex_app_server_protocol::ThreadItemPayload;
|
||||
use codex_app_server_protocol::ThreadStatus;
|
||||
use codex_app_server_protocol::TurnStatus;
|
||||
use codex_protocol::ThreadId;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum State {
|
||||
Starting,
|
||||
Running,
|
||||
Waiting,
|
||||
Idle,
|
||||
Completed,
|
||||
Stopped,
|
||||
Failed,
|
||||
Closed,
|
||||
Unavailable,
|
||||
}
|
||||
|
||||
impl State {
|
||||
pub(super) fn active(self) -> bool {
|
||||
matches!(self, Self::Starting | Self::Running | Self::Waiting)
|
||||
}
|
||||
|
||||
pub(super) fn supersedes(self, previous: Option<Self>, start_hint: bool) -> bool {
|
||||
// Spawn activity can arrive after the child's own completion notification.
|
||||
!(previous.is_some_and(Self::done)
|
||||
&& (matches!(self, Self::Idle | Self::Unavailable) || start_hint && !self.done()))
|
||||
}
|
||||
|
||||
pub(super) fn done(self) -> bool {
|
||||
matches!(
|
||||
self,
|
||||
Self::Completed | Self::Stopped | Self::Failed | Self::Closed
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn label(self) -> (&'static str, &'static str) {
|
||||
match self {
|
||||
Self::Starting => ("●", "Starting"),
|
||||
Self::Running => ("●", "Running"),
|
||||
Self::Waiting => ("●", "Waiting"),
|
||||
Self::Idle => ("○", "Idle"),
|
||||
Self::Completed => ("○", "Completed"),
|
||||
Self::Stopped => ("○", "Stopped"),
|
||||
Self::Failed => ("!", "Failed"),
|
||||
Self::Closed => ("○", "Closed"),
|
||||
Self::Unavailable => ("○", "Unavailable"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn thread_status(status: &ThreadStatus) -> State {
|
||||
match status {
|
||||
ThreadStatus::Active { active_flags } if !active_flags.is_empty() => State::Waiting,
|
||||
ThreadStatus::Active { .. } => State::Running,
|
||||
ThreadStatus::Idle => State::Idle,
|
||||
ThreadStatus::SystemError => State::Failed,
|
||||
ThreadStatus::NotLoaded => State::Unavailable,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn observe(event: &ServerNotification, overview: &mut Overview) -> bool {
|
||||
let Overview {
|
||||
members,
|
||||
states,
|
||||
restored_outcomes,
|
||||
..
|
||||
} = overview;
|
||||
let item = match event {
|
||||
ServerNotification::ItemStarted(e) => Some(&e.item.payload),
|
||||
ServerNotification::ItemCompleted(e) => Some(&e.item.payload),
|
||||
_ => None,
|
||||
};
|
||||
let mut changed = false;
|
||||
let mut update = |raw: &str, state: State, start_hint| {
|
||||
let Ok(id) = ThreadId::from_string(raw) else {
|
||||
return;
|
||||
};
|
||||
if !members.contains(&id) || !state.supersedes(states.get(&id).copied(), start_hint) {
|
||||
return;
|
||||
}
|
||||
restored_outcomes.remove(&id);
|
||||
changed |= states.insert(id, state) != Some(state);
|
||||
};
|
||||
match event {
|
||||
ServerNotification::ThreadStarted(e) => {
|
||||
update(
|
||||
&e.thread.id,
|
||||
thread_status(&e.thread.status),
|
||||
/*start_hint*/ false,
|
||||
)
|
||||
}
|
||||
ServerNotification::ThreadStatusChanged(e) => {
|
||||
update(
|
||||
&e.thread_id,
|
||||
thread_status(&e.status),
|
||||
/*start_hint*/ false,
|
||||
)
|
||||
}
|
||||
ServerNotification::ThreadClosed(e) => {
|
||||
update(&e.thread_id, State::Unavailable, /*start_hint*/ false)
|
||||
}
|
||||
ServerNotification::TurnStarted(e) => {
|
||||
update(&e.thread_id, State::Running, /*start_hint*/ false)
|
||||
}
|
||||
ServerNotification::TurnCompleted(e) => update(
|
||||
&e.thread_id,
|
||||
match e.turn.status {
|
||||
TurnStatus::Completed => State::Completed,
|
||||
TurnStatus::Interrupted => State::Stopped,
|
||||
TurnStatus::Failed => State::Failed,
|
||||
TurnStatus::InProgress => State::Running,
|
||||
},
|
||||
/*start_hint*/ false,
|
||||
),
|
||||
_ => {}
|
||||
}
|
||||
if let Some(item) = item {
|
||||
visit_item(item, update);
|
||||
}
|
||||
changed
|
||||
}
|
||||
|
||||
pub(super) fn visit_item(item: &ThreadItemPayload, mut update: impl FnMut(&str, State, bool)) {
|
||||
match item {
|
||||
ThreadItemPayload::SubAgentActivity {
|
||||
agent_thread_id,
|
||||
kind,
|
||||
..
|
||||
} => match kind {
|
||||
SubAgentActivityKind::Started => {
|
||||
update(agent_thread_id, State::Running, /*start_hint*/ true)
|
||||
}
|
||||
SubAgentActivityKind::Completed => {
|
||||
update(agent_thread_id, State::Completed, /*start_hint*/ false)
|
||||
}
|
||||
SubAgentActivityKind::Interrupted => {
|
||||
update(agent_thread_id, State::Stopped, /*start_hint*/ false)
|
||||
}
|
||||
// Ordinary mailbox delivery emits this too; it need not start a turn.
|
||||
SubAgentActivityKind::Interacted => {}
|
||||
},
|
||||
ThreadItemPayload::CollabAgentToolCall {
|
||||
agents_states,
|
||||
tool,
|
||||
..
|
||||
} => {
|
||||
for (id, state) in agents_states {
|
||||
update(
|
||||
id,
|
||||
match state.status {
|
||||
CollabAgentStatus::PendingInit => State::Starting,
|
||||
CollabAgentStatus::Running => State::Running,
|
||||
CollabAgentStatus::Interrupted => State::Stopped,
|
||||
CollabAgentStatus::Completed => State::Completed,
|
||||
CollabAgentStatus::Errored => State::Failed,
|
||||
CollabAgentStatus::Shutdown => State::Closed,
|
||||
CollabAgentStatus::NotFound => State::Unavailable,
|
||||
},
|
||||
*tool == CollabAgentTool::SpawnAgent,
|
||||
);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sidebar_agent_status_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,294 @@
|
||||
#![cfg(test)]
|
||||
|
||||
use super::*;
|
||||
use codex_app_server_protocol::ItemCompletedNotification;
|
||||
use codex_app_server_protocol::ThreadClosedNotification;
|
||||
use codex_app_server_protocol::ThreadStatusChangedNotification;
|
||||
use codex_app_server_protocol::TurnCompletedNotification;
|
||||
use pretty_assertions::assert_eq;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::HashSet;
|
||||
|
||||
#[test]
|
||||
fn idle_preserves_explicit_outcome_until_new_work() {
|
||||
let id = ThreadId::new();
|
||||
let mut overview = Overview {
|
||||
members: HashSet::from([id]),
|
||||
..Default::default()
|
||||
};
|
||||
let thread_status = |status| {
|
||||
ServerNotification::ThreadStatusChanged(ThreadStatusChangedNotification {
|
||||
thread_id: id.to_string(),
|
||||
status,
|
||||
})
|
||||
};
|
||||
let completed = |status| {
|
||||
ServerNotification::TurnCompleted(TurnCompletedNotification {
|
||||
thread_id: id.to_string(),
|
||||
turn: crate::app::tests::test_turn("turn", status, Vec::new()),
|
||||
})
|
||||
};
|
||||
let completed_item = |item| {
|
||||
ServerNotification::ItemCompleted(ItemCompletedNotification::new(
|
||||
ThreadId::new().to_string(),
|
||||
"parent-turn".into(),
|
||||
item,
|
||||
/*started_at_ms*/ None,
|
||||
/*completed_at_ms*/ 0,
|
||||
))
|
||||
};
|
||||
let activity = |kind| {
|
||||
completed_item(ThreadItemPayload::SubAgentActivity {
|
||||
model: None,
|
||||
reasoning_effort: None,
|
||||
id: "activity".into(),
|
||||
kind,
|
||||
agent_thread_id: id.to_string(),
|
||||
agent_path: "/root/worker".into(),
|
||||
})
|
||||
};
|
||||
observe(&thread_status(ThreadStatus::Idle), &mut overview);
|
||||
assert_eq!(overview.states, HashMap::from([(id, State::Idle)]));
|
||||
observe(&completed(TurnStatus::Completed), &mut overview);
|
||||
observe(&thread_status(ThreadStatus::Idle), &mut overview);
|
||||
observe(&activity(SubAgentActivityKind::Interacted), &mut overview);
|
||||
observe(&activity(SubAgentActivityKind::Started), &mut overview);
|
||||
observe(
|
||||
&completed_item(ThreadItemPayload::CollabAgentToolCall {
|
||||
id: "spawn".into(),
|
||||
tool: CollabAgentTool::SpawnAgent,
|
||||
status: codex_app_server_protocol::CollabAgentToolCallStatus::Completed,
|
||||
sender_thread_id: ThreadId::new().to_string(),
|
||||
receiver_thread_ids: vec![id.to_string()],
|
||||
prompt: None,
|
||||
model: None,
|
||||
reasoning_effort: None,
|
||||
agents_states: HashMap::from([(
|
||||
id.to_string(),
|
||||
codex_app_server_protocol::CollabAgentState {
|
||||
status: CollabAgentStatus::Running,
|
||||
message: None,
|
||||
},
|
||||
)]),
|
||||
}),
|
||||
&mut overview,
|
||||
);
|
||||
assert_eq!(overview.states, HashMap::from([(id, State::Completed)]));
|
||||
observe(
|
||||
&thread_status(ThreadStatus::Active {
|
||||
active_flags: Vec::new(),
|
||||
}),
|
||||
&mut overview,
|
||||
);
|
||||
assert_eq!(overview.states, HashMap::from([(id, State::Running)]));
|
||||
observe(&completed(TurnStatus::Failed), &mut overview);
|
||||
observe(&thread_status(ThreadStatus::Idle), &mut overview);
|
||||
observe(&thread_status(ThreadStatus::NotLoaded), &mut overview);
|
||||
observe(
|
||||
&ServerNotification::ThreadClosed(ThreadClosedNotification {
|
||||
thread_id: id.to_string(),
|
||||
}),
|
||||
&mut overview,
|
||||
);
|
||||
assert_eq!(overview.states, HashMap::from([(id, State::Failed)]));
|
||||
// Parent activity may be our only evidence of a later successful turn.
|
||||
observe(&activity(SubAgentActivityKind::Completed), &mut overview);
|
||||
assert_eq!(overview.states, HashMap::from([(id, State::Completed)]));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn chooser_lists_subagents_by_observed_outcome() -> color_eyre::Result<()> {
|
||||
use crate::app::owned_transcript::tests::attach_thread;
|
||||
use crate::app::sidebar::PaneFocus;
|
||||
use crate::app::sidebar::SidebarContent;
|
||||
use crate::app::test_support::enable_side_retention;
|
||||
use crate::app::test_support::side_frame;
|
||||
use crate::app::tests::make_test_app_with_channels;
|
||||
let (mut app, _events, _ops) = make_test_app_with_channels().await;
|
||||
enable_side_retention(&mut app)?;
|
||||
let root = ThreadId::new();
|
||||
attach_thread(&mut app, root);
|
||||
app.primary_thread_id = Some(root);
|
||||
app.local_settings.tui.animations = false;
|
||||
let first = ThreadId::new();
|
||||
let second = ThreadId::new();
|
||||
for (id, name) in [
|
||||
(first, "Source navigation reviewer with a long name"),
|
||||
(second, "Builder"),
|
||||
] {
|
||||
assert!(app.register_sidebar_agent(root, id));
|
||||
app.upsert_agent_picker_thread(
|
||||
id,
|
||||
Some(name.into()),
|
||||
/*agent_role*/ None,
|
||||
/*is_closed*/ false,
|
||||
);
|
||||
}
|
||||
app.agent_navigation.mark_parent_owned(first);
|
||||
app.observe_sidebar_agent_event(&ServerNotification::TurnCompleted(
|
||||
TurnCompletedNotification {
|
||||
thread_id: second.to_string(),
|
||||
turn: crate::app::tests::test_turn("done", TurnStatus::Completed, vec![]),
|
||||
},
|
||||
));
|
||||
app.sidebar_mut()
|
||||
.show(SidebarContent::Chooser, PaneFocus::Sidebar);
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
for (name, width) in [("subagent_chooser", 210), ("subagent_chooser_narrow", 120)] {
|
||||
let screen = side_frame(&mut app, &mut tui, ratatui::layout::Size::new(width, 25))?;
|
||||
let rows = screen
|
||||
.lines()
|
||||
.filter_map(|line| line.split_once('│').map(|(_, row)| row.trim_end()))
|
||||
.filter(|row| !row.trim().is_empty())
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
insta::assert_snapshot!(name, rows);
|
||||
}
|
||||
|
||||
let pane = app.sidebar_mut();
|
||||
let old_index = pane.chat_tabs().agent_index(second).expect("second agent");
|
||||
pane.choice = old_index;
|
||||
app.observe_sidebar_agent_event(&ServerNotification::TurnCompleted(
|
||||
TurnCompletedNotification {
|
||||
thread_id: first.to_string(),
|
||||
turn: crate::app::tests::test_turn("done", TurnStatus::Completed, vec![]),
|
||||
},
|
||||
));
|
||||
app.observe_sidebar_agent_event(&ServerNotification::ThreadStatusChanged(
|
||||
ThreadStatusChangedNotification {
|
||||
thread_id: second.to_string(),
|
||||
status: ThreadStatus::Active {
|
||||
active_flags: Vec::new(),
|
||||
},
|
||||
},
|
||||
));
|
||||
side_frame(&mut app, &mut tui, ratatui::layout::Size::new(120, 25))?;
|
||||
let pane = app.sidebar().unwrap();
|
||||
assert_eq!(pane.choice, old_index - 1);
|
||||
assert_eq!(
|
||||
pane.chat_tabs().agent(pane.choice).map(|agent| agent.id),
|
||||
Some(second)
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn active_discovery_supersedes_restored_completion() -> color_eyre::Result<()> {
|
||||
use crate::app::owned_transcript::tests::attach_thread;
|
||||
use crate::app::test_support::enable_side_retention;
|
||||
use crate::app::tests::make_test_app_with_channels;
|
||||
|
||||
let (mut app, _events, _ops) = Box::pin(make_test_app_with_channels()).await;
|
||||
enable_side_retention(&mut app)?;
|
||||
let config = app.chat_widget.config_ref();
|
||||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(config)).await?;
|
||||
let root = ThreadId::new();
|
||||
let child = ThreadId::from_string(
|
||||
&app_test_support::create_fake_paginated_rollout(
|
||||
config.codex_home.as_path(),
|
||||
"2025-01-05T12-00-00",
|
||||
"2025-01-05T12:00:00Z",
|
||||
"Child conversation",
|
||||
Some(config.model_provider_id.as_str()),
|
||||
/*git_info*/ None,
|
||||
)
|
||||
.expect("seed child history"),
|
||||
)?;
|
||||
let mut thread = Box::pin(server.thread_read(child, /*include_turns*/ false)).await?;
|
||||
thread.status = ThreadStatus::Active {
|
||||
active_flags: Vec::new(),
|
||||
};
|
||||
|
||||
let completed = ThreadId::new();
|
||||
let mut completed_thread = thread.clone();
|
||||
completed_thread.id = completed.to_string();
|
||||
attach_thread(&mut app, root);
|
||||
app.primary_thread_id = Some(root);
|
||||
let failed = ThreadId::new();
|
||||
let mut failed_thread = thread.clone();
|
||||
failed_thread.id = failed.to_string();
|
||||
failed_thread.status = ThreadStatus::SystemError;
|
||||
let outcomes = [child, completed]
|
||||
.into_iter()
|
||||
.flat_map(|id| {
|
||||
[
|
||||
SubAgentActivityKind::Completed,
|
||||
SubAgentActivityKind::Started,
|
||||
]
|
||||
.into_iter()
|
||||
.map(move |kind| ThreadItemPayload::SubAgentActivity {
|
||||
id: format!("completed-{id}"),
|
||||
kind,
|
||||
agent_thread_id: id.to_string(),
|
||||
agent_path: "/root/worker".into(),
|
||||
model: None,
|
||||
reasoning_effort: None,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
app.register_sidebar_agent(root, child);
|
||||
app.observe_sidebar_agent_event(&ServerNotification::ThreadStatusChanged(
|
||||
ThreadStatusChangedNotification {
|
||||
thread_id: child.to_string(),
|
||||
status: thread.status.clone(),
|
||||
},
|
||||
));
|
||||
app.restore_sidebar_agent_outcomes(
|
||||
root,
|
||||
&[crate::app::tests::test_turn(
|
||||
"saved-turn",
|
||||
TurnStatus::Completed,
|
||||
outcomes,
|
||||
)],
|
||||
super::super::OutcomeReplay::Reconnect,
|
||||
);
|
||||
for id in [child, completed] {
|
||||
app.upsert_agent_picker_thread(
|
||||
id,
|
||||
Some("worker".into()),
|
||||
/*agent_role*/ None,
|
||||
/*is_closed*/ false,
|
||||
);
|
||||
}
|
||||
let rows = |app: &crate::app::App| {
|
||||
app.sidebar()
|
||||
.unwrap()
|
||||
.agents
|
||||
.chooser_rows(&app.agent_navigation)
|
||||
.into_iter()
|
||||
.map(|row| (row.id, row.status))
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
assert!(rows(&app).iter().all(|(_, state)| *state == "Completed"));
|
||||
let request = app
|
||||
.agent_navigation
|
||||
.begin_picker_refresh(root)
|
||||
.expect("start discovery");
|
||||
// A completion arriving while the refresh is in flight wins over the active snapshot.
|
||||
app.observe_sidebar_agent_event(&ServerNotification::TurnCompleted(
|
||||
TurnCompletedNotification {
|
||||
thread_id: completed.to_string(),
|
||||
turn: crate::app::tests::test_turn("fresh-turn", TurnStatus::Completed, Vec::new()),
|
||||
},
|
||||
));
|
||||
app.apply_agent_picker_thread_refresh(
|
||||
&server,
|
||||
root,
|
||||
request,
|
||||
Ok(crate::app_event::AgentPickerThreadRefresh {
|
||||
threads: vec![thread, completed_thread, failed_thread],
|
||||
archived_thread_ids: HashSet::new(),
|
||||
}),
|
||||
);
|
||||
assert_eq!(
|
||||
rows(&app),
|
||||
vec![
|
||||
(child, "Running"),
|
||||
(completed, "Completed"),
|
||||
(failed, "Failed")
|
||||
]
|
||||
);
|
||||
server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -57,11 +57,17 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
files.promote(entries.into_iter().rev());
|
||||
let mut pane = super::super::sidebar::SidebarPane::default();
|
||||
pane.files = Some(files);
|
||||
pane.agents.rows.push(sidebar_chooser::AgentRow {
|
||||
id: ThreadId::new(),
|
||||
name: "Reviewer".into(),
|
||||
symbol: "○",
|
||||
status: "Completed",
|
||||
});
|
||||
pane.choice = pane.chat_tabs().file_start();
|
||||
pane.update_saved_chats(vec![ThreadId::new().into()]);
|
||||
assert_eq!(pane.chat_tabs().file_offset(pane.choice), Some(0));
|
||||
let area = Rect::new(
|
||||
/*x*/ 0, /*y*/ 0, /*width*/ 50, /*height*/ 23,
|
||||
/*x*/ 0, /*y*/ 0, /*width*/ 50, /*height*/ 30,
|
||||
);
|
||||
let mut buffer = Buffer::empty(area);
|
||||
sidebar_chooser::paint(
|
||||
@@ -98,6 +104,11 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
|
||||
○ Side chat
|
||||
|
||||
Subagents 1
|
||||
|
||||
○ Reviewer
|
||||
Completed
|
||||
|
||||
Files 4
|
||||
|
||||
› · Makefile
|
||||
@@ -119,7 +130,7 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
location: None,
|
||||
}]);
|
||||
let wide = Rect::new(
|
||||
/*x*/ 0, /*y*/ 0, /*width*/ 75, /*height*/ 20,
|
||||
/*x*/ 0, /*y*/ 0, /*width*/ 75, /*height*/ 24,
|
||||
);
|
||||
let mut wide_buffer = Buffer::empty(wide);
|
||||
let frames = tui::FrameRequester::test_dummy();
|
||||
@@ -152,8 +163,9 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
insta::assert_snapshot!(file_rows, @"
|
||||
› · Makefile Project root
|
||||
· guide.md notes
|
||||
· guide.md /Users/example/workspaces/re…ect-name/codex-rs/tui/src/app
|
||||
· guide.md /Users/example/workspaces/re…ct-name/codex-rs/tui/src/app
|
||||
");
|
||||
let right_padding = usize::from(sidebar_chooser::body_row(wide, wide.y).right() - 1);
|
||||
let [selected, hovered]: [_; 2] = wide_buffer
|
||||
.content
|
||||
.chunks(usize::from(wide.width))
|
||||
@@ -161,7 +173,13 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
let text = cells.iter().map(Cell::symbol).collect::<String>();
|
||||
text.contains("Makefile") || text.contains("/Users/example")
|
||||
})
|
||||
.map(|row| (row[2].bg, row[2].modifier))
|
||||
.map(|row| {
|
||||
assert_eq!(
|
||||
(row[right_padding].symbol(), row[right_padding].bg),
|
||||
(" ", row[2].bg)
|
||||
);
|
||||
(row[2].bg, row[2].modifier)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.try_into()
|
||||
.expect("selected and hovered files");
|
||||
@@ -228,7 +246,7 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
let tabs = pane.chat_tabs();
|
||||
let targets: Vec<_> =
|
||||
sidebar_chooser::row_targets(area, tabs, pane.choice, NewChatState::Available).collect();
|
||||
for row in 10..=12 {
|
||||
for row in (10..=12).chain(15..=17) {
|
||||
assert!(
|
||||
targets
|
||||
.iter()
|
||||
@@ -239,6 +257,14 @@ fn sidebar_files_chooser_matches_the_grouped_file_inventory() -> color_eyre::eyr
|
||||
targets
|
||||
.iter()
|
||||
.find(|(_, area)| area.contains((1, 13).into()))
|
||||
.and_then(|(index, _)| tabs.agent(*index))
|
||||
.map(|agent| agent.name.as_str()),
|
||||
Some("Reviewer"),
|
||||
);
|
||||
assert_eq!(
|
||||
targets
|
||||
.iter()
|
||||
.find(|(_, area)| area.contains((1, 18).into()))
|
||||
.and_then(|(index, _)| tabs.file(*index)),
|
||||
tabs.file(pane.choice),
|
||||
);
|
||||
|
||||
@@ -0,0 +1,253 @@
|
||||
//! Sidebar subagents follow the primary conversation's spawn tree and retain observed outcomes.
|
||||
use super::*;
|
||||
use crate::sidebar_chooser::AgentRow;
|
||||
use codex_app_server_protocol::CollabAgentStatus;
|
||||
use codex_app_server_protocol::CollabAgentTool;
|
||||
use codex_app_server_protocol::ThreadStatus;
|
||||
use std::collections::HashSet;
|
||||
|
||||
#[path = "sidebar_agent_status.rs"]
|
||||
mod status;
|
||||
use status::State;
|
||||
|
||||
pub(super) enum OutcomeReplay {
|
||||
History,
|
||||
Reconnect,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Overview {
|
||||
members: HashSet<ThreadId>,
|
||||
states: HashMap<ThreadId, State>,
|
||||
restored_outcomes: HashSet<ThreadId>,
|
||||
pub(super) rows: Vec<AgentRow>,
|
||||
}
|
||||
|
||||
impl Overview {
|
||||
pub(super) fn chooser_rows(&self, nav: &AgentNavigationState) -> Vec<AgentRow> {
|
||||
let mut rows: Vec<_> = nav
|
||||
.visible_threads()
|
||||
.into_iter()
|
||||
.filter(|(id, _)| self.members.contains(id))
|
||||
.map(|(id, entry)| {
|
||||
let state = self.states.get(&id).copied().unwrap_or(if entry.is_closed {
|
||||
State::Unavailable
|
||||
} else if entry.is_running {
|
||||
State::Running
|
||||
} else {
|
||||
State::Idle
|
||||
});
|
||||
(id, entry, state)
|
||||
})
|
||||
.collect();
|
||||
rows.sort_by_key(|(_, _, state)| (!state.active(), state.done()));
|
||||
rows.into_iter()
|
||||
.map(|(id, entry, state)| {
|
||||
let name = entry
|
||||
.agent_path
|
||||
.as_deref()
|
||||
.map(|path| path.strip_prefix("/root/").unwrap_or(path).to_owned())
|
||||
.unwrap_or_else(|| {
|
||||
if entry.agent_nickname.is_none() && entry.agent_role.is_none() {
|
||||
id.to_string()
|
||||
} else {
|
||||
format_agent_picker_item_name(
|
||||
entry.agent_nickname.as_deref(),
|
||||
entry.agent_role.as_deref(),
|
||||
/*is_primary*/ false,
|
||||
)
|
||||
}
|
||||
});
|
||||
let (symbol, status) = state.label();
|
||||
AgentRow {
|
||||
id,
|
||||
name,
|
||||
symbol,
|
||||
status,
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl App {
|
||||
pub(super) fn is_sidebar_agent(&self, id: ThreadId) -> bool {
|
||||
self.primary_thread_id
|
||||
.and_then(|root| self.sidebars.get(&Some(root)))
|
||||
.is_some_and(|pane| pane.agents.members.contains(&id))
|
||||
}
|
||||
pub(in crate::app) fn restore_sidebar_agent_outcomes(
|
||||
&mut self,
|
||||
root: ThreadId,
|
||||
turns: &[codex_app_server_protocol::Turn],
|
||||
source: OutcomeReplay,
|
||||
) {
|
||||
let mut restored = HashMap::new();
|
||||
for item in turns.iter().flat_map(|turn| &turn.items) {
|
||||
status::visit_item(&item.payload, |raw, state, start_hint| {
|
||||
if let Ok(id) = ThreadId::from_string(raw)
|
||||
&& state.supersedes(restored.get(&id).copied(), start_hint)
|
||||
{
|
||||
restored.insert(id, state);
|
||||
}
|
||||
});
|
||||
}
|
||||
for (id, state) in restored {
|
||||
if state.done()
|
||||
&& self.register_sidebar_agent(root, id)
|
||||
&& let Some(tabs) = self.sidebars.get_mut(&Some(root))
|
||||
&& tabs.agents.states.get(&id).is_none_or(|previous| {
|
||||
matches!(source, OutcomeReplay::Reconnect) && previous.active()
|
||||
})
|
||||
{
|
||||
tabs.agents.states.insert(id, state);
|
||||
tabs.agents.restored_outcomes.insert(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Active or failed discovery supersedes saved history. Live notifications can arrive during
|
||||
// discovery and take precedence over its response.
|
||||
pub(super) fn seed_discovered_sidebar_agent(
|
||||
&mut self,
|
||||
root: ThreadId,
|
||||
child: ThreadId,
|
||||
status: &ThreadStatus,
|
||||
) {
|
||||
if let Some(pane) = self.sidebars.get_mut(&Some(root))
|
||||
&& (pane.agents.restored_outcomes.remove(&child)
|
||||
|| !pane.agents.states.contains_key(&child))
|
||||
{
|
||||
pane.agents
|
||||
.states
|
||||
.insert(child, status::thread_status(status));
|
||||
}
|
||||
}
|
||||
|
||||
pub(in crate::app) fn register_sidebar_agent(
|
||||
&mut self,
|
||||
parent: ThreadId,
|
||||
child: ThreadId,
|
||||
) -> bool {
|
||||
let Some(root) = self.primary_thread_id else {
|
||||
return false;
|
||||
};
|
||||
if !self.local_settings.workspace_enabled(&self.config) || root == child {
|
||||
return false;
|
||||
}
|
||||
let parents = &mut self.sidebars;
|
||||
if parent != root
|
||||
&& !parents
|
||||
.get(&Some(root))
|
||||
.is_some_and(|t| t.agents.members.contains(&parent))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let tabs = parents.entry(Some(root)).or_default();
|
||||
if tabs.agents.members.insert(child) {
|
||||
self.chat_widget.request_redraw();
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
pub(in crate::app) fn observe_sidebar_agent_event(&mut self, event: &ServerNotification) {
|
||||
if !self.local_settings.workspace_enabled(&self.config) {
|
||||
return;
|
||||
}
|
||||
match event {
|
||||
ServerNotification::ThreadStarted(e) => {
|
||||
if let Some(parent) =
|
||||
super::loaded_threads::thread_spawn_parent_thread_id(&e.thread.source)
|
||||
&& let Ok(child) = ThreadId::from_string(&e.thread.id)
|
||||
&& self.register_sidebar_agent(parent, child)
|
||||
{
|
||||
self.upsert_agent_picker_thread(
|
||||
child,
|
||||
e.thread.agent_nickname.clone(),
|
||||
e.thread.agent_role.clone(),
|
||||
/*is_closed*/ false,
|
||||
);
|
||||
self.agent_navigation.set_agent_path(
|
||||
child,
|
||||
crate::app_server_session::source_agent_path(&e.thread.source),
|
||||
);
|
||||
self.agent_navigation.set_running(
|
||||
child,
|
||||
matches!(e.thread.status, ThreadStatus::Active { .. }),
|
||||
);
|
||||
if crate::app_server_session::thread_blocks_direct_input(&e.thread) {
|
||||
self.agent_navigation.mark_parent_owned(child);
|
||||
}
|
||||
}
|
||||
}
|
||||
ServerNotification::ThreadStatusChanged(e) => {
|
||||
if let Ok(id) = ThreadId::from_string(&e.thread_id)
|
||||
&& self.is_sidebar_agent(id)
|
||||
{
|
||||
self.agent_navigation
|
||||
.set_running(id, matches!(e.status, ThreadStatus::Active { .. }));
|
||||
self.chat_widget.request_redraw();
|
||||
}
|
||||
}
|
||||
ServerNotification::ItemStarted(_) | ServerNotification::ItemCompleted(_) => {
|
||||
let (sender, item) = match event {
|
||||
ServerNotification::ItemStarted(e) => (&e.thread_id, &e.item.payload),
|
||||
ServerNotification::ItemCompleted(e) => (&e.thread_id, &e.item.payload),
|
||||
_ => return,
|
||||
};
|
||||
let Ok(parent) = ThreadId::from_string(sender) else {
|
||||
return;
|
||||
};
|
||||
if let Some(activity) = sub_agent_activity_display(item) {
|
||||
if self.register_sidebar_agent(parent, activity.thread_id) {
|
||||
self.agent_navigation.record_sub_agent_activity(activity);
|
||||
self.chat_widget.request_redraw();
|
||||
}
|
||||
} else if let ThreadItemPayload::CollabAgentToolCall {
|
||||
tool,
|
||||
receiver_thread_ids,
|
||||
agents_states,
|
||||
..
|
||||
} = item
|
||||
{
|
||||
for id in receiver_thread_ids {
|
||||
let Ok(child) = ThreadId::from_string(id) else {
|
||||
continue;
|
||||
};
|
||||
let state = agents_states.get(id);
|
||||
if state.is_some_and(|s| s.status == CollabAgentStatus::NotFound) {
|
||||
continue;
|
||||
}
|
||||
if *tool == CollabAgentTool::SpawnAgent
|
||||
&& self.register_sidebar_agent(parent, child)
|
||||
&& self.agent_navigation.get(&child).is_none()
|
||||
{
|
||||
self.upsert_agent_picker_thread(
|
||||
child, /*agent_nickname*/ None, /*agent_role*/ None,
|
||||
/*is_closed*/ false,
|
||||
);
|
||||
}
|
||||
if let Some(state) = state
|
||||
&& self.is_sidebar_agent(child)
|
||||
{
|
||||
let running = matches!(
|
||||
state.status,
|
||||
CollabAgentStatus::PendingInit | CollabAgentStatus::Running
|
||||
);
|
||||
self.agent_navigation.set_running(child, running);
|
||||
self.chat_widget.request_redraw();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
let mut changed = false;
|
||||
for tabs in self.sidebars.values_mut() {
|
||||
changed |= status::observe(event, &mut tabs.agents);
|
||||
}
|
||||
if changed {
|
||||
self.chat_widget.request_redraw();
|
||||
}
|
||||
}
|
||||
}
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
---
|
||||
source: tui/src/app/sidebar_agent_status_tests.rs
|
||||
expression: rows
|
||||
---
|
||||
+
|
||||
Open in sidebar
|
||||
› + New side chat Available after first message
|
||||
Subagents 2
|
||||
○ Source navigation reviewer with a long name Idle
|
||||
○ Builder Completed
|
||||
esc back · ↑/↓ move · ⌃x - hide pane
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
---
|
||||
source: tui/src/app/sidebar_agent_status_tests.rs
|
||||
expression: rows
|
||||
---
|
||||
+
|
||||
Open in sidebar
|
||||
› + New side chat
|
||||
Available after first message
|
||||
Subagents 2
|
||||
○ Source navigation reviewer with…
|
||||
Idle
|
||||
○ Builder
|
||||
Completed
|
||||
esc back · ↑/↓ move · ⌃x - hide pane
|
||||
+2
-3
@@ -1,6 +1,5 @@
|
||||
---
|
||||
source: tui/src/app/tests.rs
|
||||
assertion_line: 3679
|
||||
expression: "states.join(\"\\n\\n\")"
|
||||
---
|
||||
Loading
|
||||
@@ -69,7 +68,7 @@ Refreshed chats
|
||||
Side chats 2
|
||||
|
||||
› ○ Named sibling
|
||||
Latest request with 界 界 界 a…
|
||||
Latest request with 界 界 界 …
|
||||
○ Child-only prompt
|
||||
|
||||
Readable reply
|
||||
@@ -82,6 +81,6 @@ Readable reply
|
||||
Side chats 2
|
||||
|
||||
› ○ Named sibling
|
||||
> Which branch? Keep ## My r…
|
||||
> Which branch? Keep ## My …
|
||||
○ Child-only prompt
|
||||
↓
|
||||
|
||||
@@ -10393,7 +10393,7 @@ async fn resizing_empty_transcript_schedules_settled_size_recheck() {
|
||||
);
|
||||
}
|
||||
|
||||
fn test_turn(turn_id: &str, status: TurnStatus, items: Vec<ThreadItemPayload>) -> Turn {
|
||||
pub(super) fn test_turn(turn_id: &str, status: TurnStatus, items: Vec<ThreadItemPayload>) -> Turn {
|
||||
Turn {
|
||||
id: turn_id.to_string(),
|
||||
root_turn_id: None,
|
||||
|
||||
@@ -1621,6 +1621,21 @@ impl App {
|
||||
self.recap.reset_for_new_thread(Instant::now());
|
||||
}
|
||||
self.primary_thread_id = Some(thread_id);
|
||||
if self.local_settings.workspace_enabled(&self.config)
|
||||
&& matches!(
|
||||
presentation,
|
||||
ThreadAttachPresentation::SessionLineage
|
||||
| ThreadAttachPresentation::SessionLineageAfterClear
|
||||
)
|
||||
{
|
||||
self.restore_sidebar_agent_outcomes(
|
||||
thread_id,
|
||||
&turns,
|
||||
super::sidebar_subagents::OutcomeReplay::History,
|
||||
);
|
||||
self.app_event_tx
|
||||
.send(AppEvent::DiscoverSidebarAgents(thread_id));
|
||||
}
|
||||
self.agents_overview.hidden_threads.remove(&thread_id);
|
||||
self.agents_overview.threads.entry(thread_id).or_default();
|
||||
self.primary_session_configured = Some(session.clone());
|
||||
@@ -1891,6 +1906,18 @@ impl App {
|
||||
mut snapshot: ThreadEventSnapshot,
|
||||
resume_restored_queue: bool,
|
||||
) {
|
||||
if let Some(root) = self.primary_thread_id
|
||||
&& snapshot
|
||||
.session
|
||||
.as_ref()
|
||||
.is_some_and(|s| s.thread_id == root)
|
||||
{
|
||||
self.restore_sidebar_agent_outcomes(
|
||||
root,
|
||||
&snapshot.turns,
|
||||
super::sidebar_subagents::OutcomeReplay::History,
|
||||
);
|
||||
}
|
||||
let mut reasoning_replay = reasoning_replay::ReasoningReplay::new(&mut snapshot);
|
||||
let replayed_final_items = realtime_delivery::completed_agent_items(&snapshot);
|
||||
let replayed_voice_texts = realtime_delivery::replayed_voice_texts(&snapshot);
|
||||
|
||||
Reference in New Issue
Block a user