mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +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:
@@ -291,6 +291,7 @@ mod sidebar_close;
|
||||
mod sidebar_document;
|
||||
mod sidebar_files;
|
||||
pub(crate) mod sidebar_loading;
|
||||
mod sidebar_subagents;
|
||||
mod startup;
|
||||
pub(crate) mod startup_bootstrap;
|
||||
mod startup_prompts;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -489,6 +489,8 @@ pub(crate) enum AppEvent {
|
||||
},
|
||||
/// Open the agent picker for switching active threads.
|
||||
OpenAgentPicker,
|
||||
/// Discover saved subagents on the owning backend after attaching a primary thread.
|
||||
DiscoverSidebarAgents(ThreadId),
|
||||
/// Merge a completed root-scoped agent-picker refresh without blocking terminal input.
|
||||
AgentPickerThreadsLoaded {
|
||||
primary_thread_id: ThreadId,
|
||||
|
||||
@@ -106,7 +106,9 @@ pub(crate) fn footer(
|
||||
let visible = choice_is_visible(area, tabs, choice);
|
||||
let movement = [ListAction::MoveUp, ListAction::MoveDown]
|
||||
.into_iter()
|
||||
.filter(|_| new_chat == NewChatState::Available || !tabs.files.is_empty())
|
||||
.filter(|_| {
|
||||
new_chat == NewChatState::Available || !tabs.files.is_empty() || !tabs.agents.is_empty()
|
||||
})
|
||||
.filter_map(hint)
|
||||
.collect::<Vec<_>>()
|
||||
.join("/");
|
||||
@@ -117,7 +119,10 @@ pub(crate) fn footer(
|
||||
(
|
||||
hint(ListAction::Accept)
|
||||
.filter(|_| {
|
||||
visible && (new_chat == NewChatState::Available || selected_file.is_some())
|
||||
visible
|
||||
&& (new_chat == NewChatState::Available
|
||||
|| selected_file.is_some()
|
||||
|| tabs.agent(choice).is_some())
|
||||
})
|
||||
.filter(|_| selected_file.is_none() || tabs.file_preview_unavailable.is_none()),
|
||||
if tabs.retry_row(choice)
|
||||
@@ -195,6 +200,14 @@ pub(crate) enum OpenState {
|
||||
Failed(String),
|
||||
}
|
||||
|
||||
/// An agent displayed in the shared sidebar chooser.
|
||||
pub(crate) struct AgentRow {
|
||||
pub(crate) id: ThreadId,
|
||||
pub(crate) name: String,
|
||||
pub(crate) symbol: &'static str,
|
||||
pub(crate) status: &'static str,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub(crate) struct ChatTabs<'a> {
|
||||
pub(crate) label_style: ThreadLabelStyle,
|
||||
@@ -203,6 +216,7 @@ pub(crate) struct ChatTabs<'a> {
|
||||
pub(crate) ids: &'a [SidebarTab],
|
||||
// Chooser index zero is reserved for New side chat.
|
||||
pub(crate) choices: &'a [SideChat],
|
||||
pub(crate) agents: &'a [AgentRow],
|
||||
pub(crate) latest_prompts: &'a HashMap<ThreadId, String>,
|
||||
pub(crate) selected: Option<SidebarTab>,
|
||||
pub(crate) files: &'a [FileLink],
|
||||
@@ -224,8 +238,24 @@ impl<'a> ChatTabs<'a> {
|
||||
self.file_start() + self.files.len()
|
||||
}
|
||||
|
||||
pub(crate) fn agent(self, index: usize) -> Option<&'a AgentRow> {
|
||||
self.agents.get(index.checked_sub(self.first_agent())?)
|
||||
}
|
||||
|
||||
pub(crate) fn agent_index(self, id: ThreadId) -> Option<usize> {
|
||||
self.agents
|
||||
.iter()
|
||||
.position(|agent| agent.id == id)
|
||||
.map(|offset| self.first_agent() + offset)
|
||||
}
|
||||
|
||||
fn first_agent(self) -> usize {
|
||||
let end = self.choices.len() + 1;
|
||||
end + usize::from(self.retry_row(end))
|
||||
}
|
||||
|
||||
pub(crate) fn file_start(self) -> usize {
|
||||
self.choices.len() + 1 + usize::from(self.retry_row(self.choices.len() + 1))
|
||||
self.first_agent() + self.agents.len()
|
||||
}
|
||||
|
||||
pub(crate) fn file_offset(self, index: usize) -> Option<usize> {
|
||||
@@ -283,11 +313,14 @@ pub(crate) fn tab_strip(
|
||||
SidebarTab::Document(id) => Line::from(document_title(id, width)),
|
||||
SidebarTab::Chat(id) => {
|
||||
let name = match tabs.choice_index(id) {
|
||||
Some(number) => match side_chat_label(&tabs.choices[number - 1]) {
|
||||
Some(name) => name.to_owned(),
|
||||
None if tabs.choices.len() > 1 => format!("Side {number}"),
|
||||
None => "Side chat".to_owned(),
|
||||
},
|
||||
Some(index) => {
|
||||
let ordinal = index - 1;
|
||||
match side_chat_label(&tabs.choices[ordinal]) {
|
||||
Some(name) => name.to_owned(),
|
||||
None if tabs.choices.len() > 1 => format!("Side {}", ordinal + 1),
|
||||
None => "Side chat".to_owned(),
|
||||
}
|
||||
}
|
||||
None => "Side chat".to_owned(),
|
||||
};
|
||||
tabs.label_style.render(Line::from(name), width)
|
||||
@@ -320,17 +353,20 @@ struct ChoiceRows {
|
||||
wide: bool,
|
||||
height: usize,
|
||||
chats_header: Option<usize>,
|
||||
agents_header: Option<usize>,
|
||||
files_header: Option<usize>,
|
||||
choices: Vec<Range<usize>>,
|
||||
}
|
||||
|
||||
impl ChoiceRows {
|
||||
fn new(area: Rect, tabs: ChatTabs<'_>) -> Self {
|
||||
let wide = body_row(area, area.y).width >= WIDE_WIDTH;
|
||||
let width = body_row(area, area.y).width;
|
||||
let wide = width >= WIDE_WIDTH;
|
||||
let height = usize::from(area.height.saturating_sub(3));
|
||||
let mut row = FIRST_CHOICE_ROW;
|
||||
let file_start = tabs.file_start();
|
||||
let mut chats_header = None;
|
||||
let mut agents_header = None;
|
||||
let mut files_header = None;
|
||||
let choices = (0..tabs.choice_count())
|
||||
.map(|index| {
|
||||
@@ -340,13 +376,18 @@ impl ChoiceRows {
|
||||
} else if index == 1 && tabs.retry_row(index) {
|
||||
row += 2;
|
||||
}
|
||||
let file = index >= file_start;
|
||||
if index == file_start {
|
||||
let file = tabs.file_offset(index).is_some();
|
||||
let agent = tabs.agent(index).is_some();
|
||||
if agent && index == tabs.first_agent() {
|
||||
agents_header = Some(row + 1);
|
||||
row += 3;
|
||||
}
|
||||
if file && index == file_start {
|
||||
files_header = Some(row + 1);
|
||||
row += 3;
|
||||
}
|
||||
let start = row;
|
||||
let subtitle = if index == 0 || file {
|
||||
let subtitle = if index == 0 || file || agent {
|
||||
!wide
|
||||
} else {
|
||||
tabs.prompt(index).is_some()
|
||||
@@ -359,6 +400,7 @@ impl ChoiceRows {
|
||||
wide,
|
||||
height,
|
||||
chats_header,
|
||||
agents_header,
|
||||
files_header,
|
||||
choices,
|
||||
}
|
||||
@@ -497,7 +539,7 @@ pub(crate) fn row_targets(
|
||||
(first < last
|
||||
&& match tabs.file(index) {
|
||||
Some(_) => tabs.file_preview_unavailable.is_none(),
|
||||
None => new_chat == NewChatState::Available,
|
||||
None => new_chat == NewChatState::Available || tabs.agent(index).is_some(),
|
||||
})
|
||||
.then(|| Rect {
|
||||
height: (last - first) as u16,
|
||||
@@ -590,6 +632,7 @@ pub(crate) fn paint(
|
||||
crate::style::quiet_workspace_style()
|
||||
};
|
||||
let row = |y| body_row(area, y);
|
||||
let width = usize::from(row(area.y).width.saturating_sub(1));
|
||||
let footer_y = area.bottom() - 1;
|
||||
if let Some(path) = sidebar_style.full_path {
|
||||
let mut body = body_row(area, area.y + u16::from(area.height > 2) * 2);
|
||||
@@ -610,8 +653,9 @@ pub(crate) fn paint(
|
||||
return;
|
||||
}
|
||||
let rows = ChoiceRows::new(area, tabs);
|
||||
let waiting =
|
||||
sidebar_style.new_chat == NewChatState::WaitingForMainMessage && tabs.files.is_empty();
|
||||
let waiting = sidebar_style.new_chat == NewChatState::WaitingForMainMessage
|
||||
&& tabs.files.is_empty()
|
||||
&& tabs.agents.is_empty();
|
||||
let top = if waiting {
|
||||
0
|
||||
} else {
|
||||
@@ -621,14 +665,27 @@ pub(crate) fn paint(
|
||||
if let Some(y) = offset.checked_sub(top)
|
||||
&& (CHOOSER_BODY_START..CHOOSER_BODY_START + rows.height).contains(&y)
|
||||
{
|
||||
line.render(row(area.y + y as u16), buf);
|
||||
let mut content = row(area.y + y as u16);
|
||||
if content.width > 0 {
|
||||
content.width -= 1;
|
||||
buf.set_style(
|
||||
Rect::new(
|
||||
content.right(),
|
||||
content.y,
|
||||
/*width*/ 1,
|
||||
/*height*/ 1,
|
||||
),
|
||||
line.style,
|
||||
);
|
||||
}
|
||||
line.render(content, buf);
|
||||
}
|
||||
};
|
||||
paint(2, Line::from("Open in sidebar").bold());
|
||||
if waiting {
|
||||
for (offset, text) in (FIRST_CHOICE_ROW..).zip(textwrap::wrap(
|
||||
"You can start a side chat after your first message in the main chat.",
|
||||
usize::from(row(area.y).width.max(1)),
|
||||
width.max(1),
|
||||
)) {
|
||||
paint(offset, Line::from(text).dim());
|
||||
}
|
||||
@@ -674,11 +731,11 @@ pub(crate) fn paint(
|
||||
let title = format!("{marker} + New side chat");
|
||||
let detail = match sidebar_style.new_chat {
|
||||
NewChatState::Available => "Start from this conversation",
|
||||
NewChatState::WaitingForMainMessage => "Available after your first message",
|
||||
NewChatState::WaitingForMainMessage => "Available after first message",
|
||||
};
|
||||
let detail = Span::styled(detail, subtitle);
|
||||
if rows.wide {
|
||||
let pad = usize::from(row(area.y).width - 1) - detail.width();
|
||||
let pad = width - detail.width();
|
||||
paint(
|
||||
y,
|
||||
Line::from(vec![format!("{title:<pad$}").into(), detail]).style(fill),
|
||||
@@ -695,6 +752,13 @@ pub(crate) fn paint(
|
||||
Line::from(format!("Side chats {total}")).style(secondary),
|
||||
);
|
||||
}
|
||||
if let Some(y) = rows.agents_header {
|
||||
let total = tabs.agents.len();
|
||||
paint(
|
||||
y,
|
||||
Line::from(format!("Subagents {total}")).style(secondary),
|
||||
);
|
||||
}
|
||||
if let Some(y) = rows.files_header
|
||||
&& (top + CHOOSER_BODY_START..top + CHOOSER_BODY_START + rows.height).contains(&y)
|
||||
{
|
||||
@@ -710,12 +774,31 @@ pub(crate) fn paint(
|
||||
};
|
||||
paint(y, Line::from(format!("{group} {total}")).style(secondary));
|
||||
}
|
||||
let width = usize::from(row(area.y).width);
|
||||
for (index, lines) in rows
|
||||
.visible_choices(tabs.scroll, choice)
|
||||
.skip_while(|(index, _)| *index == 0)
|
||||
{
|
||||
let (marker, fill, subtitle) = row_style(index);
|
||||
if let Some(agent) = tabs.agent(index) {
|
||||
let name = format!("{marker} {} {}", agent.symbol, agent.name);
|
||||
let status = agent.status;
|
||||
if rows.wide {
|
||||
let title_width = width.saturating_sub(crate::width::display_width(status) + 2);
|
||||
let mut line = truncate_line_with_ellipsis_if_overflow(name.into(), title_width);
|
||||
let gap = title_width.saturating_sub(line.width()) + 2;
|
||||
line.spans
|
||||
.push(format!("{:gap$}{status}", "").set_style(subtitle));
|
||||
paint(lines.start, line.style(fill));
|
||||
} else {
|
||||
let title = truncate_line_with_ellipsis_if_overflow(name.into(), width);
|
||||
paint(lines.start, title.style(fill));
|
||||
paint(
|
||||
lines.start + 1,
|
||||
Line::from(format!(" {status}")).style(subtitle),
|
||||
);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if tabs.retry_row(index) {
|
||||
let label = if tabs.discovery.request().is_some() {
|
||||
"Retrying…"
|
||||
@@ -766,7 +849,8 @@ pub(crate) fn paint(
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let chat = &tabs.choices[index - 1];
|
||||
let ordinal = index - 1;
|
||||
let chat = &tabs.choices[ordinal];
|
||||
let selected = index == choice && focused;
|
||||
let label = side_chat_label(chat);
|
||||
let title = if let Some(label) = label {
|
||||
@@ -774,7 +858,7 @@ pub(crate) fn paint(
|
||||
} else if tabs.choices.len() == 1 {
|
||||
"Side chat".to_string()
|
||||
} else {
|
||||
format!("Side chat {index}")
|
||||
format!("Side chat {}", ordinal + 1)
|
||||
};
|
||||
let title = if sidebar_style.use_theme_colors && !selected {
|
||||
let identity = crate::thread_color::thread_color(chat.id);
|
||||
@@ -803,7 +887,7 @@ pub(crate) fn paint(
|
||||
OpenState::Loading(_) => "Opening…".dim(),
|
||||
OpenState::Failed(error) => format!("Retry · {error}").red(),
|
||||
};
|
||||
let width = usize::from(row(area.y).width.saturating_sub(6));
|
||||
let width = width.saturating_sub(6);
|
||||
let title = label_style.render(
|
||||
Line::from(title),
|
||||
width.saturating_sub(status.width()).max(width / 3),
|
||||
|
||||
Reference in New Issue
Block a user