Keep Cloud threads current in the Agents overview (#62858)

## Why

The Agents overview can go stale when Cloud threads change from another
client, especially when the TUI has no conversation stream attached.

## What changed

- Use Cloud stream notifications to update thread status and refresh the
  thread list. Poll every 10 seconds while the overview is visible and
  no stream is attached.
- Refresh the history already shown while preserving the `Show more`
  cursor. Use fresh list metadata for thread names, recency, and unread
  state, and restore rows when a refresh catches a missed unarchive.

## Testing

Cover Cloud inventory notifications, polling while detached, pagination
across refreshes, and recovery from a missed unarchive.

GitOrigin-RevId: 63c98438b6ddd2e47dd2d1f419c2a676508c6d91
This commit is contained in:
Benjamin Carlsson
2026-11-20 23:23:32 +00:00
committed by copyberry
parent 941e1dcade
commit beac2ef8fc
19 changed files with 608 additions and 84 deletions
+44 -4
View File
@@ -15,6 +15,7 @@ mod loading;
#[path = "agents_overview_selection.rs"]
mod selection;
use super::agents_overview_discovery::AgentsOverviewDiscovery;
use super::agents_overview_discovery::is_overview_root;
use super::agents_overview_discovery::is_visible_in_agents_overview;
use super::agents_overview_view::AgentsOverviewGroup;
@@ -59,10 +60,12 @@ pub(super) struct AgentsOverviewState {
pub(super) usage_disabled: bool,
pub(super) activity: HashMap<ThreadId, super::agents_overview_details::AgentsOverviewActivity>,
pub(super) initialized: HashSet<BackendId>,
pub(super) discovery:
HashMap<BackendId, super::agents_overview_discovery::AgentsOverviewDiscovery>,
pub(super) discovery: HashMap<BackendId, AgentsOverviewDiscovery>,
pub(super) show_more_backends: HashSet<BackendId>,
pub(super) refresh_show_more: bool,
pub(super) refresh_recent_backends: HashSet<BackendId>,
pub(super) cloud_inventory_dirty: HashSet<BackendId>,
pub(super) active_refresh_recent: bool,
pub(super) refresh_failed_backends: HashSet<BackendId>,
/// Vacancies left by lifecycle removals, tracked by the backend that owned the row.
pub(super) refill_by_backend: HashMap<BackendId, usize>,
@@ -97,6 +100,14 @@ pub(super) struct AgentsOverviewState {
}
impl AgentsOverviewState {
pub(super) fn cloud_refresh_pending(&self, owner: BackendId) -> bool {
(self.active_refresh_recent && self.active_refresh.is_some_and(|(_, id)| id == owner))
|| self
.discovery
.get(&owner)
.is_some_and(AgentsOverviewDiscovery::has_cloud_refresh_pending)
}
pub(super) fn refill_count(&self, owner: BackendId) -> usize {
self.refill_by_backend
.get(&owner)
@@ -113,7 +124,7 @@ impl AgentsOverviewState {
&& self
.discovery
.get(&owner)
.is_some_and(super::agents_overview_discovery::AgentsOverviewDiscovery::has_more)
.is_some_and(AgentsOverviewDiscovery::has_more)
}
}
@@ -152,6 +163,17 @@ impl App {
"Reconnecting — agent list is stale"
});
}
if app_server.thread_params_mode() == crate::app_server_session::ThreadParamsMode::Cloud {
let owner = app_server.backend_id();
if self.agents_overview.cloud_refresh_pending(owner) {
self.cancel_agents_overview_refresh(owner);
}
if let Some(discovery) = self.agents_overview.discovery.get_mut(&owner) {
discovery.restart_cloud_refresh();
}
self.agents_overview.cloud_inventory_dirty.remove(&owner);
self.agents_overview.refresh_recent_backends.insert(owner);
}
self.refresh_agents_overview_threads(app_server);
}
@@ -174,6 +196,7 @@ impl App {
let refill_succeeded = result
.as_ref()
.is_ok_and(|refresh| refresh.recent_seed_complete);
self.agents_overview.active_refresh_recent = false;
if !refill_succeeded {
self.agents_overview
.refresh_failed_backends
@@ -220,7 +243,18 @@ impl App {
if refresh.recent_seed_complete {
self.agents_overview.initialized.insert(refresh_backend_id);
}
if let Some(discovery) = refresh.discovery {
if let Some(mut discovery) = refresh.discovery {
// Fresh Cloud list rows can recover from a missed unarchive.
let overview = &mut self.agents_overview;
for id in discovery.fresh_cloud_page_ids.drain(..) {
if refill_succeeded
&& self.backend_registry.owner(id) == Some(refresh_backend_id)
&& !overview.pending_archives.contains_key(&id)
&& !overview.refresh_notifications.contains_key(&id)
{
overview.removed_threads.remove(&id);
}
}
if !discovery.has_more() {
self.agents_overview
.refill_by_backend
@@ -373,6 +407,7 @@ impl App {
let overview = &mut self.agents_overview;
overview.initialized.remove(&backend_id);
overview.discovery.remove(&backend_id);
overview.cloud_inventory_dirty.remove(&backend_id);
overview
.removed_threads
.retain(|thread_id| self.backend_registry.owner(*thread_id) != Some(backend_id));
@@ -404,6 +439,9 @@ impl App {
if std::mem::take(&mut overview.refresh_show_more) {
overview.show_more_backends.insert(backend_id);
}
if std::mem::take(&mut overview.active_refresh_recent) {
overview.refresh_recent_backends.insert(backend_id);
}
let removed_threads = &overview.removed_threads;
overview.refresh_thread_ids.extend(
overview
@@ -421,6 +459,8 @@ impl App {
.pending_refresh_backends
.retain(|id| *id != backend_id);
if self.backend_registry.request_handle(backend_id).is_none() {
overview.refresh_recent_backends.remove(&backend_id);
overview.cloud_inventory_dirty.remove(&backend_id);
overview.refresh_failed_backends.remove(&backend_id);
}
self.drain_agents_overview_refresh_queue();
@@ -1,4 +1,5 @@
//! Demand-driven history discovery. Each source retains its cursor and unshown rows.
//! Cloud refresh walks the displayed history independently of Show more.
//! Each new query scans the active backend from the start with its own paging cursor.
use super::App;
@@ -15,6 +16,7 @@ use codex_app_server_protocol::ThreadListParams;
use codex_app_server_protocol::ThreadListResponse;
use codex_app_server_protocol::ThreadSortKey;
use codex_app_server_protocol::ThreadSourceKind;
use codex_protocol::ThreadId;
use codex_protocol::protocol::SubAgentSource;
use codex_state::PINNED_THREAD_SECTION_ID;
use std::collections::VecDeque;
@@ -140,6 +142,10 @@ impl Default for SourcePage {
#[derive(Clone, Debug, Default)]
pub(crate) struct AgentsOverviewDiscovery {
sources: [SourcePage; 2],
// Oldest row delivered by Cloud history discovery.
cloud_frontier: Option<(i64, String)>,
cloud_refresh: Option<SourcePage>,
pub(super) fresh_cloud_page_ids: Vec<ThreadId>,
}
impl AgentsOverviewDiscovery {
@@ -149,7 +155,7 @@ impl AgentsOverviewDiscovery {
.any(|source| !source.exhausted || !source.rows.is_empty())
}
pub(super) async fn next_batch(
async fn next_batch(
&mut self,
handle: &AppServerRequestHandle,
limit: usize,
@@ -189,6 +195,77 @@ impl AgentsOverviewDiscovery {
}
(rows, left && right)
}
pub(super) fn has_cloud_refresh_pending(&self) -> bool {
self.cloud_refresh.is_some()
}
pub(super) fn restart_cloud_refresh(&mut self) {
self.cloud_refresh = None;
}
pub(super) async fn next_overview_page(
&mut self,
handle: &AppServerRequestHandle,
limit: usize,
refresh_recent: bool,
) -> (Vec<(Thread, bool)>, bool) {
if !matches!(handle, AppServerRequestHandle::Cloud(_)) {
return self.next_batch(handle, limit).await;
}
// Cloud has one source. Fetch only what we can show, even for a partial refill.
self.sources[1].exhausted = true;
let mut page = if refresh_recent {
self.cloud_refresh.take().unwrap_or_default()
} else {
self.sources[0].clone()
};
page.page_size = limit as u32;
page.sort_key = ThreadSortKey::UpdatedAt;
if !page.fill(handle, Vec::new()).await {
if refresh_recent {
self.cloud_refresh = Some(SourcePage::default());
}
return (Vec::new(), false);
}
let mut rows: Vec<_> = page.rows.drain(..).collect();
if refresh_recent && let Some((oldest, id)) = &self.cloud_frontier {
// Stop at the last row reached by Show more. Its timestamp also
// bounds the pass if that row has moved up or been archived.
if !self.sources[0].exhausted {
let boundary = rows.iter().enumerate().find_map(|(index, (thread, _))| {
if thread.updated_at < *oldest {
Some(index)
} else if thread.updated_at == *oldest && thread.id == *id {
Some(index + 1)
} else {
None
}
});
if let Some(end) = boundary {
rows.truncate(end);
page.exhausted = true;
}
}
if !page.exhausted {
self.cloud_refresh = Some(page);
}
} else if refresh_recent && rows.is_empty() && !page.exhausted {
self.cloud_refresh = Some(page);
} else {
// The first nonempty refresh of an empty list also seeds Show more.
if let Some((thread, _)) = rows.last() {
self.cloud_frontier = Some((thread.updated_at, thread.id.clone()));
}
self.sources[0] = page;
}
self.fresh_cloud_page_ids = rows
.iter()
.filter_map(|(thread, _)| ThreadId::from_string(&thread.id).ok())
.collect();
(rows, true)
}
}
impl SourcePage {
@@ -25,47 +25,77 @@ use tokio::sync::mpsc;
use tokio_tungstenite::tungstenite::Message;
#[tokio::test]
async fn overview_cloud_discovery_uses_only_interactive_pages() {
async fn overview_refresh_grows_visible_history_and_preserves_the_show_more_cursor() {
let (client, mut commands, _events) = CloudClient::channel(/*capacity*/ 1);
let handle = AppServerClient::Cloud(client).request_handle();
let threads = ["First Cloud task", "Second Cloud task"].map(|name| {
overview_thread(
ThreadId::new(),
/*parent_thread_id*/ None,
name,
ThreadStatus::NotLoaded,
)
});
let serve_pages = async {
for (thread, (cursor, next_cursor)) in threads
.iter()
.zip([(None, Some("next")), (Some("next"), None)])
{
let command = commands.recv().await.unwrap();
let CloudOperation::Request(request) = command.operation else {
panic!("expected a Cloud request");
};
let ClientRequest::ThreadList { params, .. } = *request else {
panic!("expected thread/list");
};
assert_eq!(params.source_kinds, Some(Vec::new()));
assert_eq!(params.cursor.as_deref(), cursor);
command
let parent = None;
let threads: Vec<_> = (0..66)
.map(|rank| {
let mut thread = overview_thread(ThreadId::new(), parent, "Task", ThreadStatus::Idle);
thread.updated_at -= rank;
(thread, false)
})
.collect();
let (more, refill, refresh) = (Some(10), Some(2), None);
let pages = [
(more, None, Some((12..22, Some("h1")))),
(more, Some("h1"), Some((22..32, Some("h2")))),
(more, Some("h2"), Some((32..42, Some("h3")))),
(more, Some("h3"), Some((42..52, Some("h4")))),
(more, Some("h4"), Some((52..62, Some("h5")))),
(refresh, None, Some((0..10, Some("r1")))),
(refresh, Some("r1"), None),
(refresh, None, Some((0..10, Some("r1")))),
(refresh, Some("r1"), Some((10..20, Some("r2")))),
(refill, Some("h5"), Some((62..64, Some("h6")))),
(refresh, Some("r2"), Some((20..30, Some("r3")))),
(refresh, Some("r3"), Some((30..40, Some("r4")))),
(refresh, Some("r4"), Some((40..50, Some("r5")))),
(refresh, Some("r5"), Some((50..60, Some("r6")))),
(refresh, Some("r6"), Some((60..66, Some("r7")))),
(more, Some("h6"), Some((64..66, None))),
];
let mut discovery = AgentsOverviewDiscovery::default();
let mut shown = HashSet::new();
for (history_limit, cursor, page) in pages {
let range = page.as_ref().map_or(0..0, |(range, _)| range.clone());
let clipped_end = if cursor == Some("r6") { 64 } else { range.end };
let expected = &threads[range.start..clipped_end];
let complete = page.is_some();
let response = page
.map(|(range, next)| {
let data: Vec<_> = threads[range].iter().map(|(thread, _)| thread).collect();
json!({"data": data, "nextCursor": next})
})
.ok_or_else(|| JSONRPCErrorError {
code: -32603,
message: "Temporary list failure".into(),
data: None,
});
let serve_page = async {
next_cloud_page(&mut commands, cursor)
.await
.response
.send(Ok(Ok(json!({"data": [thread], "nextCursor": next_cursor}))))
.send(Ok(response))
.unwrap();
};
let discover = discovery.next_overview_page(
&handle,
history_limit.unwrap_or(10),
history_limit.is_none(),
);
let ((rows, ok), ()) = tokio::join!(discover, serve_page);
assert_eq!((rows.as_slice(), ok), (expected, complete));
shown.extend(rows.into_iter().map(|(thread, _)| thread.id));
if cursor == Some("r1") && complete {
assert_eq!(shown.len(), 62);
}
};
let discover = async {
let mut discovery = AgentsOverviewDiscovery::default();
for (thread, has_more) in threads.iter().zip([true, false]) {
let page = discovery.next_batch(&handle, /*limit*/ 10).await;
assert_eq!(page, (vec![(thread.clone(), false)], true));
assert_eq!(discovery.has_more(), has_more);
if !complete {
assert!(discovery.has_cloud_refresh_pending());
}
};
tokio::join!(serve_pages, discover);
}
assert!(!discovery.has_cloud_refresh_pending());
assert!(!discovery.has_more());
}
#[tokio::test]
@@ -130,11 +160,21 @@ async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reope
assert!(!app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
}
// The previous archive was observed, but its unarchive notification was missed.
app.agents_overview.threads.remove(&thread_id);
app.agents_overview.removed_threads.insert(thread_id);
app.open_agents_overview(&cloud);
let reopened = tokio::time::timeout(timeout, next_list(&mut commands)).await?;
let mut listed = current.clone();
listed.name = Some("Renamed in Cloud".to_string());
listed.updated_at += 1;
listed.recency_at = Some(listed.updated_at);
let unread = json!({"revision": "1", "firstUnread": {"type": "threadStart"}});
reopened
.response
.send(Ok(Ok(json!({"data": [], "nextCursor": null}))))
.send(Ok(Ok(json!({
"data": [listed], "nextCursor": null, "readStates": {(thread_id.to_string()): unread}
}))))
.unwrap();
let read = tokio::time::timeout(timeout, commands.recv())
.await?
@@ -166,6 +206,31 @@ async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reope
finish_overview_refresh(&mut app, &cloud, &mut events).await;
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
assert!(!app.agents_overview.refresh_failed_backends.contains(&owner));
assert_eq!(
app.agents_overview.threads[&thread_id],
Some(listed.clone())
);
assert!(app.agents_overview.unread.contains(&thread_id));
app.refresh_agents_overview_threads(&cloud);
reject_cloud_pinned_list(&mut commands).await;
current.status = ThreadStatus::NotLoaded;
for response in [
json!({"thread": current, "readState": null}),
json!({"data": [], "nextCursor": null, "backwardsCursor": null}),
] {
commands
.recv()
.await
.unwrap()
.response
.send(Ok(Ok(response)))
.unwrap();
}
finish_overview_refresh(&mut app, &cloud, &mut events).await;
listed.status = current.status;
assert_eq!(app.agents_overview.threads[&thread_id], Some(listed));
assert!(app.agents_overview.unread.contains(&thread_id));
Ok(())
}
@@ -186,7 +251,9 @@ async fn resume_picker_cancels_a_held_cloud_show_more_page() -> Result<()> {
);
let mut discovery = AgentsOverviewDiscovery::default();
let handle = cloud.request_handle();
let (page, ()) = tokio::join!(discovery.next_batch(&handle, /*limit*/ 10), async {
let page =
discovery.next_overview_page(&handle, /*limit*/ 10, /*refresh_recent*/ false);
let (page, ()) = tokio::join!(page, async {
let command = next_cloud_page(&mut commands, /*cursor*/ None).await;
command
.response
@@ -375,7 +442,9 @@ async fn overview_local_enter_drops_the_displayed_cloud_list_before_detach() ->
let mut discovery = AgentsOverviewDiscovery::default();
let handle = cloud.request_handle();
let (first_page, ()) = tokio::time::timeout(timeout, async {
tokio::join!(discovery.next_batch(&handle, /*limit*/ 10), async {
let page =
discovery.next_overview_page(&handle, /*limit*/ 10, /*refresh_recent*/ false);
tokio::join!(page, async {
let command = next_cloud_page(&mut commands, /*cursor*/ None).await;
command
.response
@@ -773,6 +842,13 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
}
assert_eq!(app.agents_overview.threads.len(), 10);
assert!(app.agents_overview.threads.contains_key(&ids[10]));
let retained_id = ids[14];
let mut retained = expected[&retained_id].clone().unwrap();
retained.name = Some("Earlier task name".to_string());
assert!(app.backend_registry.observe(owner, retained_id));
app.agents_overview
.threads
.insert(retained_id, Some(retained));
let other = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
let other_owner = other.backend_id();
if mixed_sources {
@@ -820,6 +896,10 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
);
app.backend_registry.disconnect(other_owner);
other.shutdown().await?;
assert_eq!(
app.agents_overview.threads[&retained_id],
expected[&retained_id]
);
assert_eq!(
app.agents_overview
.threads
+81 -9
View File
@@ -332,9 +332,12 @@ async fn late_overview_page_only_refills_its_own_backend() {
);
app.remove_agents_overview_thread(id);
for owner in [other, displayed] {
// The displayed backend's next history page contains the restored task.
for (owner, replacement) in [(other, ThreadId::new()), (displayed, id)] {
let request_id = Uuid::new_v4();
let replacement = ThreadId::new();
let mut discovery =
crate::app::agents_overview_discovery::AgentsOverviewDiscovery::default();
discovery.fresh_cloud_page_ids.push(replacement);
let row = overview_thread(
replacement,
/*parent_thread_id*/ None,
@@ -350,7 +353,7 @@ async fn late_overview_page_only_refills_its_own_backend() {
threads: HashMap::from([(replacement, Some((row, false, None)))]),
last_messages: HashMap::new(),
recent_seed_complete: true,
discovery: None,
discovery: Some(discovery),
pinned_thread_ids: None,
}),
);
@@ -384,7 +387,20 @@ async fn queued_overview_page_survives_a_focus_change() {
app.show_more_agents_overview(&session);
app.app_server_backend_id = Some(other);
app.chat_widget
.dismiss_provider_view(AGENTS_OVERVIEW_VIEW_ID);
app.agents_overview.active_refresh = None;
app.handle_polled_backend_event(
&session,
other,
&mut HashMap::new(),
crate::app_server_session::AppServerSessionEvent {
backend_id: owner,
event: AppServerEvent::CloudInventoryChanged(None),
},
)
.await;
assert!(app.agents_overview.refresh_recent_backends.contains(&owner));
app.drain_agents_overview_refresh_queue();
assert_eq!(
app.agents_overview.pending_refresh_backends.front(),
@@ -394,12 +410,64 @@ async fn queued_overview_page_survives_a_focus_change() {
app.app_server_backend_id = Some(owner);
app.open_agents_overview(&session);
assert_eq!(
app.agents_overview.active_refresh.map(|(_, id)| id),
Some(owner)
);
assert!(app.agents_overview.pending_refresh_backends.is_empty());
let (page, page_owner) = app.agents_overview.active_refresh.unwrap();
assert_eq!(page_owner, owner);
assert!(app.agents_overview.refresh_show_more);
assert!(!app.agents_overview.active_refresh_recent);
assert!(app.agents_overview.refresh_recent_backends.contains(&owner));
app.agents_overview.refresh_task.take().unwrap().abort();
app.agents_overview.show_more_backends.insert(owner);
app.agents_overview.refill_by_backend.insert(owner, 1);
app.apply_agents_overview_thread_refresh(&session, page, Err("temporary page failure".into()));
let (recent, recent_owner) = app.agents_overview.active_refresh.unwrap();
assert_eq!(recent_owner, owner);
assert!(app.agents_overview.active_refresh_recent);
assert!(app.agents_overview.show_more_backends.contains(&owner));
let id = ThreadId::new();
for (method, archived) in [("thread/archived", true), ("thread/unarchived", false)] {
let lifecycle = serde_json::from_value(
serde_json::json!({"method": method, "params": {"threadId": id.to_string()}}),
)
.unwrap();
app.handle_app_server_event(
&session,
AppServerEvent::CloudInventoryChanged(Some(Box::new(lifecycle))),
)
.await;
assert_eq!(app.agents_overview.removed_threads.contains(&id), archived);
}
app.poll_cloud_inventory(&session, /*attached*/ true);
assert_eq!(app.agents_overview.active_refresh, Some((recent, owner)));
assert!(app.agents_overview.cloud_inventory_dirty.contains(&owner));
app.cancel_agents_overview_refresh(owner);
}
#[tokio::test]
async fn cloud_inventory_polls_when_visible_and_detached() {
let mut app = make_test_app().await;
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
let owner = BackendId::new();
let (session, _commands, _events) = overview_session_stub(owner, ThreadParamsMode::Cloud);
app.backend_registry.connect(&session);
app.app_server_backend_id = Some(owner);
app.agents_overview.initialized.insert(owner);
app.poll_cloud_inventory(&session, /*attached*/ false);
assert!(app.agents_overview.active_refresh.is_none());
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
app.chat_widget.show_bottom_pane_view(Box::new(view));
app.poll_cloud_inventory(&session, /*attached*/ true);
assert!(app.agents_overview.active_refresh.is_none());
app.poll_cloud_inventory(&session, /*attached*/ false);
assert!(app.agents_overview.active_refresh_recent);
app.agents_overview.view_state.lock().unwrap().has_more = true;
app.chat_widget.handle_key_event(KeyCode::Down.into());
app.chat_widget.handle_key_event(KeyCode::Enter.into());
assert!(
std::iter::from_fn(|| rx.try_recv().ok())
.any(|event| matches!(event, AppEvent::ShowMoreAgentsOverview))
);
app.cancel_agents_overview_refresh(owner);
}
@@ -815,6 +883,9 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re
);
// A successful read supersedes registration; queued notifications supersede the read.
retained_thread.preview = "Fresh preview from the read".to_string();
let mut discovery = crate::app::agents_overview_discovery::AgentsOverviewDiscovery::default();
discovery.fresh_cloud_page_ids = vec![archived, deleted];
app.agents_overview.active_refresh_recent = true;
app.apply_agents_overview_thread_refresh(
&app_server,
request_id,
@@ -827,7 +898,7 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re
(deleted, Some((deleted_thread, false, None))),
]),
recent_seed_complete: true,
discovery: None,
discovery: Some(discovery),
pinned_thread_ids: None,
}),
);
@@ -838,6 +909,7 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re
(created, Some(created_thread)),
]);
assert_eq!(app.agents_overview.threads, expected);
assert_eq!(app.agents_overview.refill_count(app_server.backend_id()), 0);
let request_id = Uuid::new_v4();
app.agents_overview.active_refresh = Some((request_id, app_server.backend_id()));
@@ -336,7 +336,13 @@ impl App {
}
return;
}
let cloud = matches!(&request_handle, AppServerRequestHandle::Cloud(_));
let refill = overview.refill_count(backend_id);
let page_requested = source_has_more
&& !overview.refresh_failed_backends.contains(&backend_id)
&& (refill > 0 || overview.show_more_backends.contains(&backend_id));
let refresh_recent =
!page_requested && overview.refresh_recent_backends.remove(&backend_id) && initialized;
let queued = overview.pending_refresh_backends.contains(&backend_id);
if queued {
overview
@@ -345,6 +351,7 @@ impl App {
overview.pin_refresh_requested = true;
}
let should_refresh = !initialized
|| refresh_recent
|| overview.refresh_thread_ids.iter().any(|id| {
self.backend_registry
.owner(*id)
@@ -357,6 +364,9 @@ impl App {
return;
}
if page_requested && overview.refresh_recent_backends.contains(&backend_id) {
overview.pending_refresh_backends.push_back(backend_id);
}
let mut unread_rows = Vec::new();
if std::mem::take(&mut self.agents_overview.pin_refresh_requested) {
unread_rows.extend(
@@ -375,12 +385,16 @@ impl App {
}
let request_id = Uuid::new_v4();
self.agents_overview.active_refresh = Some((request_id, backend_id));
let show_more = refill == 0
let show_more = !refresh_recent
&& 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 {
let fresh_cloud_list = cloud && (refresh_recent || !initialized);
self.agents_overview.active_refresh_recent = fresh_cloud_list;
let discover =
refresh_recent || !initialized || show_more || (refill > 0 && source_has_more);
let limit = if !refresh_recent && initialized && refill > 0 {
refill.min(10)
} else {
10
@@ -404,12 +418,30 @@ impl App {
.refresh_thread_ids
.extend(foreign_thread_ids);
self.agents_overview.active_refresh_thread_ids = thread_ids.clone();
let mut retained = HashMap::new();
if cloud {
for (&id, row) in &self.agents_overview.threads {
let Some(thread) = row else { continue };
if (!initialized || thread_ids.contains(&id))
&& self.backend_registry.owner(id) == Some(backend_id)
{
retained.insert(
id,
(
thread.clone(),
self.agents_overview.unread.contains(&id),
None,
),
);
}
}
}
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;
.loading = discover && !refresh_recent;
let refresh_task = tokio::spawn(async move {
let result = async {
let mut threads = HashMap::new();
@@ -452,8 +484,8 @@ impl App {
)
.await
};
let (loaded, (recent, complete)) =
tokio::join!(loaded, discovery.next_batch(&request_handle, limit));
let page = discovery.next_overview_page(&request_handle, limit, refresh_recent);
let (loaded, (recent, complete)) = tokio::join!(loaded, page);
let loaded = loaded.map_err(|error| error.to_string())?;
recent_seed_complete = complete;
thread_ids.extend(
@@ -492,6 +524,12 @@ impl App {
.await;
let mut reads = tokio::task::JoinSet::new();
for thread_id in thread_ids {
let listed = threads
.get(&thread_id)
.filter(|_| cloud)
.cloned()
.flatten()
.or_else(|| retained.remove(&thread_id));
threads.entry(thread_id).or_default();
let request_handle = request_handle.clone();
reads.spawn(async move {
@@ -505,7 +543,7 @@ impl App {
})
.await
{
Ok(response) => {
Ok(mut response) => {
let mut latest_prompt = None;
let mut last_message = None;
// Legacy turn listing replays the entire rollout, even for one turn.
@@ -548,9 +586,15 @@ impl App {
_ => None,
});
}
let unread = response
let mut unread = response
.read_state
.is_some_and(|state| state.first_unread.is_some());
if let Some((thread, listed_unread, _)) = listed {
response.thread.name = thread.name;
response.thread.updated_at = thread.updated_at;
response.thread.recency_at = thread.recency_at;
unread = listed_unread;
}
Some((
thread_id,
(response.thread, unread, latest_prompt),
@@ -70,6 +70,9 @@ impl App {
event: AppServerEvent,
) {
match event {
AppServerEvent::CloudInventoryChanged(lifecycle) => {
self.invalidate_cloud_inventory(app_server_client, lifecycle.as_deref())
}
AppServerEvent::Lagged { skipped } => {
tracing::warn!(
skipped,
+68
View File
@@ -2,6 +2,7 @@
//! Connection-wide lifecycle and account events may only update the displayed conversation's UI.
use super::App;
use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
use super::app_server_event_targets::ServerNotificationThreadTarget;
use super::app_server_event_targets::server_notification_thread_target;
use crate::app_server_session::AppServerSession;
@@ -25,6 +26,10 @@ impl App {
if event.backend_id != app_server.backend_id() {
return;
}
if let AppServerEvent::CloudInventoryChanged(lifecycle) = &event.event {
self.invalidate_cloud_inventory(app_server, lifecycle.as_deref());
return;
}
let invalidates_discovery = match &event.event {
AppServerEvent::Lagged { .. } | AppServerEvent::Disconnected { .. } => true,
AppServerEvent::ServerNotification(notification) => matches!(
@@ -72,6 +77,69 @@ impl App {
self.handle_backend_event(app_server, event).await;
}
pub(super) fn invalidate_cloud_inventory(
&mut self,
app_server: &AppServerSession,
lifecycle: Option<&ServerNotification>,
) {
if app_server.thread_params_mode() != crate::app_server_session::ThreadParamsMode::Cloud {
return;
}
let owner = app_server.backend_id();
let status_changed = matches!(lifecycle, Some(ServerNotification::ThreadStatusChanged(_)));
if let Some(
notification @ (ServerNotification::ThreadArchived(_)
| ServerNotification::ThreadUnarchived(_)
| ServerNotification::ThreadStatusChanged(_)),
) = lifecycle
&& let ServerNotificationThreadTarget::Thread(id) =
server_notification_thread_target(notification)
&& self.backend_registry.observe(owner, id)
{
self.track_agents_overview_notification(notification);
self.repaint_agents_overview();
if status_changed && matches!(self.agents_overview.threads.get(&id), Some(Some(_))) {
return;
}
}
if self.agents_overview.cloud_refresh_pending(owner) {
self.agents_overview.cloud_inventory_dirty.insert(owner);
return;
}
self.agents_overview.cloud_inventory_dirty.remove(&owner);
self.agents_overview.refresh_recent_backends.insert(owner);
if self.cloud_inventory_visible(owner) {
self.start_agents_overview_refresh_for_backend(owner, app_server.request_handle());
}
}
pub(super) fn cloud_inventory_visible(&self, owner: BackendId) -> bool {
self.app_server_backend_id == Some(owner)
&& !self.reconnect.offline
&& self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some()
}
pub(super) fn poll_cloud_inventory(&mut self, app_server: &AppServerSession, attached: bool) {
let owner = app_server.backend_id();
if self.agents_overview.active_refresh.is_some() || !self.cloud_inventory_visible(owner) {
return;
}
let overview = &mut self.agents_overview;
if !overview.cloud_refresh_pending(owner)
&& !overview.cloud_inventory_dirty.remove(&owner)
&& !overview.refresh_recent_backends.contains(&owner)
&& overview.initialized.contains(&owner)
&& attached
{
return;
}
overview.refresh_recent_backends.insert(owner);
self.start_agents_overview_refresh_for_backend(owner, app_server.request_handle());
}
pub(super) async fn handle_backend_event(
&mut self,
app_server: &AppServerSession,
+1
View File
@@ -298,6 +298,7 @@ impl App {
}
self.agents_overview.active_refresh = None;
self.agents_overview.refresh_show_more = false;
self.agents_overview.active_refresh_recent = false;
self.agents_overview.active_refresh_thread_ids.clear();
self.agents_overview.pending_refresh_backends.clear();
self.agents_overview.refresh_notifications.clear();
+19
View File
@@ -1343,6 +1343,9 @@ See the Codex keymap documentation for supported actions and examples."
let mut last_screen_size = tui.terminal.last_known_screen_size;
let mut settled_size_tags = crate::terminal_size_telemetry::tags(last_screen_size);
let mut pending_resize: Option<(ratatui::layout::Size, Instant)> = None;
let mut cloud_inventory_poll = tokio::time::interval(Duration::from_secs(/*secs*/ 10));
cloud_inventory_poll.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
let mut cloud_inventory_owner = None;
let mut reconnect = None;
let mut cloud_environment_picker: Option<
futures::future::LocalBoxFuture<'static, crate::bottom_pane::SelectionViewParams>,
@@ -1567,6 +1570,15 @@ See the Codex keymap documentation for supported actions and examples."
.chat_widget
.rate_limit_refresh_interval()
.and_then(|interval| app.rate_limit_refresh_state.poll_deadline(interval));
let cloud_owner = (backends.is_listening(displayed_owner)
&& backends.session_at(displayed_session).thread_params_mode()
== crate::ThreadParamsMode::Cloud
&& app.cloud_inventory_visible(displayed_owner))
.then_some(displayed_owner);
if cloud_inventory_owner != cloud_owner {
cloud_inventory_owner = cloud_owner;
cloud_inventory_poll.reset();
}
let control = select! {
result = async {
match app.daemon_restart.as_mut() {
@@ -1851,6 +1863,13 @@ See the Codex keymap documentation for supported actions and examples."
app.refresh_rate_limits(backends.session_at(displayed_session), RateLimitRefreshOrigin::Periodic);
AppRunControl::Continue
}
_ = cloud_inventory_poll.tick(), if cloud_owner.is_some() => {
let session = backends.session_at(displayed_session);
if let AppServerRequestHandle::Cloud(handle) = session.request_handle() {
app.poll_cloud_inventory(session, handle.has_attachment());
}
AppRunControl::Continue
}
() = async {
match app.chat_widget.terminal_title_next_refresh {
Some(deadline) => {
+1
View File
@@ -206,6 +206,7 @@ pub(crate) async fn handle_event_during_device_login(
Ok(false)
}
AppServerEvent::ServerNotification(_)
| AppServerEvent::CloudInventoryChanged(_)
| AppServerEvent::ThreadStreamDisconnected(_)
| AppServerEvent::ThreadStreamReconnected(_) => Ok(false),
}
+2 -1
View File
@@ -307,7 +307,8 @@ stream_max_retries = 0
return Ok::<_, color_eyre::eyre::Report>(());
}
}
codex_app_server_client::AppServerEvent::ThreadStreamReconnected(_)
codex_app_server_client::AppServerEvent::CloudInventoryChanged(_)
| codex_app_server_client::AppServerEvent::ThreadStreamReconnected(_)
| codex_app_server_client::AppServerEvent::ThreadStreamDisconnected(_) => {}
codex_app_server_client::AppServerEvent::Lagged { .. }
| codex_app_server_client::AppServerEvent::Disconnected { .. } => {
@@ -867,7 +867,8 @@ async fn run_onboarding_screen_inner(
AppServerEvent::Disconnected { message } => {
return Err(color_eyre::eyre::eyre!(message));
}
AppServerEvent::ThreadStreamReconnected(_)
AppServerEvent::CloudInventoryChanged(_)
| AppServerEvent::ThreadStreamReconnected(_)
| AppServerEvent::ThreadStreamDisconnected(_)
| AppServerEvent::Lagged { .. }
| AppServerEvent::ServerRequest(_) => {}