mirror of
https://github.com/openai/codex.git
synced 2026-11-21 22:50:37 +00:00
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:
committed by
copyberry
parent
941e1dcade
commit
beac2ef8fc
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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),
|
||||
}
|
||||
|
||||
@@ -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(_) => {}
|
||||
|
||||
Reference in New Issue
Block a user