Files
codex/codex-rs/tui/src/app/agents_overview_threads.rs
T
Benjamin Carlsson 2f7c5a8588 Cancel Cloud overview refreshes that block TUI navigation (#62150)
## Why

An in-flight Cloud task list from the agents overview can keep the Cloud
worker busy while the TUI waits for a session request, such as listing
tasks in the resume picker or unsubscribing from a discarded blank task.

## What changed

Cancel the affected backend's Cloud overview refresh when dismissing the
overview or before session operations that need the same worker. Wait for
the aborted task to drop its request before proceeding. When opening the
resume picker, clear queued Cloud refreshes first so canceling the active
refresh cannot start another page ahead of the picker's requests.

## Testing

Add regression tests that hold Cloud list requests open while returning to
the current chat, opening the resume picker, or switching backends.
Cover canceling a refresh before starting a fresh plan implementation
session and preserving another backend's in-flight page during archive.

GitOrigin-RevId: 94993aa0014ac895a30f454e3ff5f4cbc45bb429
2026-11-18 01:35:51 +00:00

599 lines
26 KiB
Rust

//! Retains overview membership for this TUI, independently of server subscriptions.
//! Each backend owns its initialization and discovery cursor. A bounded recent seed runs
//! at startup, after reconnect, and after event lag. Reopening also checks the
//! newest rows on parked backends.
//! Discovery merges into retained membership without evicting rows.
use super::App;
use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
use super::agents_overview_details::preview_agent_message;
use super::agents_overview_discovery::AgentsOverviewDiscovery;
use super::agents_overview_discovery::is_overview_root;
use super::agents_overview_discovery::list_pinned_threads;
use super::app_server_event_targets::ServerNotificationThreadTarget;
use super::app_server_event_targets::server_notification_thread_target;
use crate::app_event::AgentsOverviewThreadRefresh;
use crate::app_event::AppEvent;
use crate::app_server_session::AppServerSession;
use crate::backend_id::BackendId;
use crate::chatwidget::ChatWidget;
use codex_app_server_client::AppServerRequestHandle;
use codex_app_server_protocol::ClientRequest;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::ServerNotification;
use codex_app_server_protocol::Thread;
use codex_app_server_protocol::ThreadHistoryMode;
use codex_app_server_protocol::ThreadItemPayload;
use codex_app_server_protocol::ThreadLoadedListParams;
use codex_app_server_protocol::ThreadLoadedListResponse;
use codex_app_server_protocol::ThreadReadParams;
use codex_app_server_protocol::ThreadReadResponse;
use codex_app_server_protocol::ThreadStatus;
use codex_app_server_protocol::ThreadTurnsListParams;
use codex_app_server_protocol::ThreadTurnsListResponse;
use codex_protocol::ThreadId;
use futures::StreamExt;
use std::collections::HashMap;
use std::collections::HashSet;
use uuid::Uuid;
const RECENT_DETAIL_LIMIT: usize = 10;
// Listing supplies membership and row metadata without replaying every historical rollout.
// Keep transcript previews fresh for recent and loaded tasks, plus notification-targeted reads.
fn detail_thread_ids<'a>(threads: impl Iterator<Item = &'a Thread>) -> Vec<ThreadId> {
let mut threads: Vec<_> = threads.collect();
threads.sort_by(|left, right| {
right
.recency_at
.unwrap_or(right.updated_at)
.cmp(&left.recency_at.unwrap_or(left.updated_at))
.then_with(|| right.id.cmp(&left.id))
});
threads
.into_iter()
.enumerate()
.filter(|(index, thread)| {
*index < RECENT_DETAIL_LIMIT || thread.status != ThreadStatus::NotLoaded
})
.filter_map(|(_, thread)| ThreadId::from_string(&thread.id).ok())
.collect()
}
impl App {
pub(super) fn remove_agents_overview_thread(&mut self, thread_id: ThreadId) {
self.prepare_agents_overview_removal(&std::collections::HashSet::from([thread_id]));
self.agents_overview.search_matches.remove(&thread_id);
self.agents_overview.removed_threads.insert(thread_id);
self.agents_overview
.refresh_notifications
.remove(&thread_id);
self.agents_overview.unread.remove(&thread_id);
if let Some(Some(thread)) = self.agents_overview.threads.remove(&thread_id)
&& is_overview_root(&thread)
&& !self.agents_overview.hidden_threads.contains(&thread_id)
&& let Some(owner) = self.backend_registry.owner(thread_id)
{
*self
.agents_overview
.refill_by_backend
.entry(owner)
.or_default() += 1;
}
}
pub(super) fn show_more_agents_overview(&mut self, app_server: &AppServerSession) {
let owner = app_server.backend_id();
if self
.agents_overview
.discovery
.get(&owner)
.is_some_and(AgentsOverviewDiscovery::has_more)
&& let Some(handle) = self.backend_registry.request_handle(owner)
{
if self.agents_overview.refill_count(owner) == 0 {
self.agents_overview.show_more_backends.insert(owner);
}
self.start_agents_overview_refresh_for_backend(owner, handle);
}
}
pub(super) fn track_agents_overview_notification(&mut self, notification: &ServerNotification) {
let ServerNotificationThreadTarget::Thread(thread_id) =
server_notification_thread_target(notification)
else {
return;
};
if matches!(
notification,
ServerNotification::TurnStarted(_)
| ServerNotification::ThreadClosed(_)
| ServerNotification::ThreadArchived(_)
| ServerNotification::ThreadDeleted(_)
) {
self.agents_overview.blank_sessions.remove(&thread_id);
self.agents_overview
.draft_cloud_environments
.remove(&thread_id);
}
self.track_agents_overview_activity(thread_id, notification);
let thread = self
.agents_overview
.threads
.get_mut(&thread_id)
.and_then(Option::as_mut)
.or_else(|| self.agents_overview.search_matches.get_mut(&thread_id));
match notification {
ServerNotification::ThreadReadStateChanged(change) => {
if change.read_state.first_unread.is_some() {
self.agents_overview.unread.insert(thread_id);
} else {
self.agents_overview.unread.remove(&thread_id);
}
self.repaint_agents_overview();
}
ServerNotification::ThreadTokenUsageUpdated(usage) => {
if self.agents_overview.threads.contains_key(&thread_id) {
self.agents_overview
.usage
.entry(thread_id)
.or_default()
.tokens = Some(usage.token_usage.total.clone());
self.repaint_agents_overview();
}
}
ServerNotification::ThreadStarted(started) => {
if started.thread.ephemeral {
return;
}
self.agents_overview.removed_threads.remove(&thread_id);
let mut thread = started.thread.clone();
thread.turns.clear();
self.agents_overview.search_matches.remove(&thread_id);
self.agents_overview.threads.insert(thread_id, Some(thread));
}
ServerNotification::ThreadArchived(_) | ServerNotification::ThreadDeleted(_) => {
self.agents_overview
.requested_permission_profiles
.remove(&thread_id);
self.agents_overview
.selected_permission_profiles
.remove(&thread_id);
self.agents_overview.activity.remove(&thread_id);
self.agents_overview.last_messages.remove(&thread_id);
self.agents_overview.usage.remove(&thread_id);
self.remove_agents_overview_thread(thread_id);
self.agents_overview.refresh_thread_ids.remove(&thread_id);
}
ServerNotification::ThreadUnarchived(_) => {
self.agents_overview.removed_threads.remove(&thread_id);
}
ServerNotification::ThreadClosed(_) => {
self.agents_overview
.requested_permission_profiles
.remove(&thread_id);
if let Some(message) = self
.agents_overview
.activity
.remove(&thread_id)
.and_then(|activity| activity.last_message)
{
self.agents_overview
.last_messages
.insert(thread_id, message);
}
if let Some(usage) = self.agents_overview.usage.get_mut(&thread_id) {
usage.tokens = None;
}
if let Some(thread) = thread {
thread.status = ThreadStatus::NotLoaded;
}
}
ServerNotification::ThreadReverted(_) => {
self.agents_overview.activity.remove(&thread_id);
self.agents_overview.last_messages.remove(&thread_id);
if let Some(usage) = self.agents_overview.usage.get_mut(&thread_id) {
usage.tokens = None;
}
self.repaint_agents_overview();
}
ServerNotification::ThreadStatusChanged(status) => {
if let Some(thread) = thread {
thread.status = status.status.clone();
}
}
ServerNotification::ThreadNameUpdated(name) => {
if let Some(thread) = thread {
thread.name.clone_from(&name.thread_name);
}
}
ServerNotification::ThreadSettingsUpdated(settings) => {
if !self.pending_server_profiles.contains_key(&thread_id)
&& !self
.agents_overview
.requested_permission_profiles
.contains_key(&thread_id)
&& self
.agents_overview
.selected_permission_profiles
.get(&thread_id)
!= settings
.thread_settings
.active_permission_profile
.as_ref()
.map(|profile| &profile.id)
{
self.agents_overview
.selected_permission_profiles
.remove(&thread_id);
}
if let Some(thread) = thread {
thread.cwd.clone_from(&settings.thread_settings.cwd);
thread.model = Some(settings.thread_settings.model.clone());
thread
.model_provider
.clone_from(&settings.thread_settings.model_provider);
}
}
_ => return,
}
if !matches!(
notification,
ServerNotification::ThreadReverted(_)
| ServerNotification::ThreadTokenUsageUpdated(_)
| ServerNotification::ThreadReadStateChanged(_)
) && self.agents_overview.threads.contains_key(&thread_id)
{
self.agents_overview.refresh_thread_ids.insert(thread_id);
}
if self.agents_overview.active_refresh.is_some() {
// Replay the latest notification of each kind after the read, in arrival order.
// This also protects sessions whose metadata has not arrived in the initial seed.
let pending = self
.agents_overview
.refresh_notifications
.entry(thread_id)
.or_default();
pending.retain(|previous| {
std::mem::discriminant(previous) != std::mem::discriminant(notification)
});
pending.push(notification.clone());
}
}
pub(super) fn refresh_agents_overview_threads(&mut self, app_server: &AppServerSession) {
self.agents_overview.pin_refresh_requested = true;
self.agents_overview.refresh_thread_ids.extend(
self.agents_overview
.threads
.iter()
.filter_map(|(id, thread)| thread.is_none().then_some(*id)),
);
self.agents_overview
.refresh_thread_ids
.extend(detail_thread_ids(
self.agents_overview.threads.values().flatten(),
));
self.start_agents_overview_refresh(app_server);
}
pub(super) fn refresh_changed_agents_overview_threads(
&mut self,
app_server: &AppServerSession,
) {
if self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_none()
{
return;
}
self.agents_overview.pin_refresh_requested = true;
self.start_agents_overview_refresh(app_server);
}
fn start_agents_overview_refresh(&mut self, app_server: &AppServerSession) {
let backend_id = app_server.backend_id();
if self.reconnect.offline
|| self
.app_server_backend_id
.is_some_and(|owner| owner != backend_id)
{
return;
}
self.backend_registry.connect(app_server);
self.start_agents_overview_refresh_for_backend(backend_id, app_server.request_handle());
}
pub(super) fn start_agents_overview_refresh_for_backend(
&mut self,
backend_id: BackendId,
request_handle: AppServerRequestHandle,
) {
if self.reconnect.offline
&& self
.app_server_backend_id
.is_none_or(|owner| owner == backend_id)
{
return;
}
let overview = &mut self.agents_overview;
let initialized = overview.initialized.contains(&backend_id);
let source_has_more = overview
.discovery
.get(&backend_id)
.is_none_or(AgentsOverviewDiscovery::has_more);
let visible = self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some();
if !visible && initialized {
return;
}
if overview.active_refresh.is_some() {
if !overview.pending_refresh_backends.contains(&backend_id) {
overview.pending_refresh_backends.push_back(backend_id);
}
return;
}
let refill = overview.refill_count(backend_id);
let queued = overview.pending_refresh_backends.contains(&backend_id);
if queued {
overview
.pending_refresh_backends
.retain(|id| *id != backend_id);
overview.pin_refresh_requested = true;
}
let should_refresh = !initialized
|| overview.refresh_thread_ids.iter().any(|id| {
self.backend_registry
.owner(*id)
.is_none_or(|owner| owner == backend_id)
})
|| overview.show_more_backends.contains(&backend_id)
|| (refill > 0 && source_has_more)
|| overview.pin_refresh_requested;
if !should_refresh {
return;
}
let mut unread_rows = Vec::new();
if std::mem::take(&mut self.agents_overview.pin_refresh_requested) {
unread_rows.extend(
self.agents_overview
.visible_thread_ids
.iter()
.copied()
.filter(|id| {
self.agents_overview.unread.contains(id)
&& self
.backend_registry
.owner(*id)
.is_none_or(|owner| owner == backend_id)
}),
);
}
let request_id = Uuid::new_v4();
self.agents_overview.active_refresh = Some((request_id, backend_id));
let show_more = refill == 0
&& source_has_more
&& self.agents_overview.show_more_backends.remove(&backend_id);
self.agents_overview.refresh_show_more = show_more;
let discover = !initialized || show_more || (refill > 0 && source_has_more);
let limit = if initialized && refill > 0 {
refill.min(10)
} else {
10
};
let mut discovery = discover.then(|| {
self.agents_overview
.discovery
.get(&backend_id)
.cloned()
.unwrap_or_default()
});
let (mut thread_ids, foreign_thread_ids) =
std::mem::take(&mut self.agents_overview.refresh_thread_ids)
.into_iter()
.partition::<HashSet<_>, _>(|thread_id| {
self.backend_registry
.owner(*thread_id)
.is_none_or(|owner| owner == backend_id)
});
self.agents_overview
.refresh_thread_ids
.extend(foreign_thread_ids);
self.agents_overview.active_refresh_thread_ids = thread_ids.clone();
let app_event_tx = self.app_event_tx.clone();
self.agents_overview
.view_state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.loading = discover;
let refresh_task = tokio::spawn(async move {
let result = async {
let mut threads = HashMap::new();
let mut last_messages = HashMap::new();
let mut recent_seed_complete = true;
let pinned_thread_ids = match list_pinned_threads(&request_handle).await {
Ok(Some(pinned_threads)) => {
let mut ids = Vec::with_capacity(pinned_threads.len());
for (thread, is_unread) in pinned_threads {
if let Ok(thread_id) = ThreadId::from_string(&thread.id) {
ids.push(thread_id);
threads.insert(thread_id, Some((thread, is_unread, None)));
}
}
Some(Some(ids))
}
Ok(None) => Some(None),
Err(error) => {
tracing::warn!(%error, "failed to list pinned agent threads");
None
}
};
if let Some(discovery) = &mut discovery {
let loaded = async {
if initialized {
return Ok(ThreadLoadedListResponse {
data: Vec::new(),
next_cursor: None,
});
}
request_handle
.request_typed::<ThreadLoadedListResponse>(
ClientRequest::ThreadLoadedList {
request_id: RequestId::String(Uuid::new_v4().to_string()),
params: ThreadLoadedListParams {
cursor: None,
limit: None,
},
},
)
.await
};
let (loaded, (recent, complete)) =
tokio::join!(loaded, discovery.next_batch(&request_handle, limit));
let loaded = loaded.map_err(|error| error.to_string())?;
recent_seed_complete = complete;
thread_ids.extend(
loaded
.data
.into_iter()
.filter_map(|id| ThreadId::from_string(&id).ok()),
);
thread_ids.extend(detail_thread_ids(recent.iter().map(|(thread, _)| thread)));
for (thread, is_unread) in recent {
if let Ok(thread_id) = ThreadId::from_string(&thread.id) {
threads.insert(thread_id, Some((thread, is_unread, None)));
}
}
}
// Recheck dots on older rows without fetching their transcript previews.
unread_rows.retain(|id| !threads.contains_key(id) && !thread_ids.contains(id));
let cleared_unread = futures::stream::iter(unread_rows)
.map(async |id| {
let response: ThreadReadResponse = request_handle
.request_typed(ClientRequest::ThreadRead {
request_id: RequestId::String(Uuid::new_v4().to_string()),
params: ThreadReadParams {
thread_id: id.to_string(),
include_turns: false,
},
})
.await
.ok()?;
response.read_state?.first_unread.is_none().then_some(id)
})
.buffer_unordered(16)
.filter_map(std::future::ready)
.collect()
.await;
let mut reads = tokio::task::JoinSet::new();
for thread_id in thread_ids {
threads.entry(thread_id).or_default();
let request_handle = request_handle.clone();
reads.spawn(async move {
match request_handle
.request_typed::<ThreadReadResponse>(ClientRequest::ThreadRead {
request_id: RequestId::String(Uuid::new_v4().to_string()),
params: ThreadReadParams {
thread_id: thread_id.to_string(),
include_turns: false,
},
})
.await
{
Ok(response) => {
let mut latest_prompt = None;
let mut last_message = None;
// Legacy turn listing replays the entire rollout, even for one turn.
if response.thread.history_mode == ThreadHistoryMode::Paginated
&& let Ok(turns) = request_handle
.request_typed::<ThreadTurnsListResponse>(
ClientRequest::ThreadTurnsList {
request_id: RequestId::String(
Uuid::new_v4().to_string(),
),
params: ThreadTurnsListParams {
thread_id: thread_id.to_string(),
cursor: None,
limit: Some(1),
sort_direction: None,
items_view: None,
},
},
)
.await
&& let Some(turn) = turns.data.first()
{
if let Some(ThreadItemPayload::UserMessage {
content, ..
}) = turn.item_payloads().next()
{
latest_prompt =
Some(super::agents_overview_details::preview_markdown(
&ChatWidget::user_message_display_from_inputs(
content,
)
.message,
));
}
last_message =
turn.item_payloads().rev().find_map(|item| match item {
ThreadItemPayload::AgentMessage { text, .. } => {
Some(preview_agent_message(text))
}
_ => None,
});
}
let unread = response
.read_state
.is_some_and(|state| state.first_unread.is_some());
Some((
thread_id,
(response.thread, unread, latest_prompt),
last_message,
))
}
Err(error) => {
tracing::warn!(%thread_id, %error, "failed to read agent thread");
None
}
}
});
if reads.len() >= 16
&& let Some(Ok(Some((thread_id, thread, last_message)))) =
reads.join_next().await
{
threads.insert(thread_id, Some(thread));
if let Some(message) = last_message {
last_messages.insert(thread_id, message);
}
}
}
while let Some(result) = reads.join_next().await {
if let Ok(Some((thread_id, thread, last_message))) = result {
threads.insert(thread_id, Some(thread));
if let Some(message) = last_message {
last_messages.insert(thread_id, message);
}
}
}
Ok(AgentsOverviewThreadRefresh {
cleared_unread,
threads,
last_messages,
recent_seed_complete,
discovery,
pinned_thread_ids,
})
}
.await;
app_event_tx.send(AppEvent::AgentsOverviewThreadsLoaded { request_id, result });
});
self.agents_overview.refresh_task = Some(refresh_task);
}
}