mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
Keep agent overview refresh state scoped to each backend (#61596)
## Why Switching backends while an overview refresh is pending can lose queued pagination or let a late page consume another backend's refill budget. ## What changed - Track queued refreshes, “Show more” requests, refill counts, and refresh failures per backend. - Preserve pending work across backend switches and use registered live request handles to refresh the owning backend. - Cancel stale reads for the affected backend after mutations, event lag, or disconnects, and hide “Show more” when its backend is disconnected. ## Testing Add regression coverage for pagination across focus changes, backend-specific refills, pin completion, stale reads after event lag, and connection registration during reconnect. GitOrigin-RevId: 3429b2b3ac93156b4dc4234ad042431d26c84525
This commit is contained in:
committed by
copyberry
parent
e8e5108c97
commit
b7056f3408
@@ -1,5 +1,5 @@
|
||||
//! Overview of recent and locally retained sessions and their subagents.
|
||||
//! Tasks owned by another app server open as frozen, read-only history snapshots.
|
||||
//! Overview of recent and locally retained sessions across registered backends.
|
||||
//! Selecting a task on another backend prepares its owner before switching the UI.
|
||||
//! Only the immediate attachment of a dashboard-created task is treated as fresh.
|
||||
|
||||
#[path = "agents_overview_new.rs"]
|
||||
@@ -26,14 +26,13 @@ use super::*;
|
||||
use crate::app_event::AgentsOverviewThreadRefresh;
|
||||
use crate::backend_id::BackendId;
|
||||
use crate::bottom_pane::BottomPaneView;
|
||||
use crate::bottom_pane::SelectionItem;
|
||||
use crate::bottom_pane::SelectionViewParams;
|
||||
use crate::chatwidget::ThreadInputStateRestoreMode;
|
||||
use crate::startup_draft::StartupDraftPump;
|
||||
use codex_app_server_protocol::SessionSource;
|
||||
use codex_app_server_protocol::Thread;
|
||||
use codex_app_server_protocol::ThreadHistoryMode;
|
||||
use codex_protocol::protocol::SubAgentSource;
|
||||
use std::collections::VecDeque;
|
||||
|
||||
pub(crate) const AGENTS_OVERVIEW_VIEW_ID: &str = "agents-overview";
|
||||
|
||||
@@ -57,13 +56,14 @@ pub(super) struct AgentsOverviewState {
|
||||
pub(super) initialized: HashSet<BackendId>,
|
||||
pub(super) discovery:
|
||||
HashMap<BackendId, super::agents_overview_discovery::AgentsOverviewDiscovery>,
|
||||
pub(super) show_more_requested: bool,
|
||||
pub(super) show_more_backends: HashSet<BackendId>,
|
||||
pub(super) refresh_show_more: bool,
|
||||
/// Vacancies left by lifecycle removals, filled without expanding the visible window.
|
||||
pub(super) refill_count: usize,
|
||||
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>,
|
||||
pub(super) active_refresh: Option<(Uuid, BackendId)>,
|
||||
pub(super) refresh_pending: bool,
|
||||
pub(super) refresh_invalidated: bool,
|
||||
/// Other backends queued while the shared overview refresh slot is occupied.
|
||||
pub(super) pending_refresh_backends: VecDeque<BackendId>,
|
||||
pub(super) pin_refresh_requested: bool,
|
||||
pub(super) refresh_thread_ids: HashSet<ThreadId>,
|
||||
pub(super) active_refresh_thread_ids: HashSet<ThreadId>,
|
||||
@@ -89,30 +89,23 @@ pub(super) struct AgentsOverviewState {
|
||||
}
|
||||
|
||||
impl AgentsOverviewState {
|
||||
pub(super) fn invalidate_discovery(&mut self, backend: BackendId, displayed: bool) {
|
||||
self.initialized.remove(&backend);
|
||||
self.discovery.remove(&backend);
|
||||
if displayed {
|
||||
self.reset_visible_pagination();
|
||||
self.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.has_more = false;
|
||||
}
|
||||
self.refresh_invalidated |= self
|
||||
.active_refresh
|
||||
.is_some_and(|(_, owner)| owner == backend);
|
||||
pub(super) fn refill_count(&self, owner: BackendId) -> usize {
|
||||
self.refill_by_backend
|
||||
.get(&owner)
|
||||
.copied()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
pub(super) fn reset_visible_pagination(&mut self) {
|
||||
self.show_more_requested = false;
|
||||
self.refill_count = 0;
|
||||
}
|
||||
|
||||
pub(super) fn has_more(&self, backend_id: BackendId) -> bool {
|
||||
self.discovery
|
||||
.get(&backend_id)
|
||||
.is_none_or(super::agents_overview_discovery::AgentsOverviewDiscovery::has_more)
|
||||
pub(super) fn has_more_for(
|
||||
&self,
|
||||
registry: &super::backend_registry::BackendRegistry,
|
||||
owner: BackendId,
|
||||
) -> bool {
|
||||
registry.request_handle(owner).is_some()
|
||||
&& self
|
||||
.discovery
|
||||
.get(&owner)
|
||||
.is_some_and(super::agents_overview_discovery::AgentsOverviewDiscovery::has_more)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -150,9 +143,8 @@ impl App {
|
||||
} else {
|
||||
"Reconnecting — agent list is stale"
|
||||
});
|
||||
} else {
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
}
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
}
|
||||
|
||||
pub(super) fn apply_agents_overview_thread_refresh(
|
||||
@@ -171,10 +163,21 @@ impl App {
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.active_refresh_thread_ids.clear();
|
||||
self.agents_overview.refresh_task = None;
|
||||
let invalidated = std::mem::take(&mut self.agents_overview.refresh_invalidated);
|
||||
let refill_succeeded = result
|
||||
.as_ref()
|
||||
.is_ok_and(|refresh| refresh.recent_seed_complete);
|
||||
if !refill_succeeded {
|
||||
self.agents_overview
|
||||
.refresh_failed_backends
|
||||
.insert(refresh_backend_id);
|
||||
} else if result
|
||||
.as_ref()
|
||||
.is_ok_and(|refresh| refresh.discovery.is_some())
|
||||
{
|
||||
self.agents_overview
|
||||
.refresh_failed_backends
|
||||
.remove(&refresh_backend_id);
|
||||
}
|
||||
{
|
||||
let mut state = self
|
||||
.agents_overview
|
||||
@@ -182,10 +185,12 @@ impl App {
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
state.loading = false;
|
||||
state.refresh_failed = !invalidated && !refill_succeeded;
|
||||
state.refresh_failed = self
|
||||
.agents_overview
|
||||
.refresh_failed_backends
|
||||
.contains(&app_server.backend_id());
|
||||
}
|
||||
match result {
|
||||
_ if invalidated => self.agents_overview.refresh_notifications.clear(),
|
||||
Ok(mut refresh) => {
|
||||
for id in refresh.cleared_unread {
|
||||
self.agents_overview.unread.remove(&id);
|
||||
@@ -204,29 +209,29 @@ impl App {
|
||||
.pins_by_backend
|
||||
.insert(refresh_backend_id, pins);
|
||||
}
|
||||
let displayed_refresh = refresh_backend_id == app_server.backend_id();
|
||||
if refresh.discovery.is_some()
|
||||
|| (displayed_refresh && refresh.recent_seed_complete)
|
||||
{
|
||||
if refresh.recent_seed_complete {
|
||||
self.agents_overview.initialized.insert(refresh_backend_id);
|
||||
} else if displayed_refresh {
|
||||
self.agents_overview.initialized.remove(&refresh_backend_id);
|
||||
}
|
||||
if let Some(discovery) = refresh.discovery {
|
||||
if displayed_refresh {
|
||||
let has_more = discovery.has_more();
|
||||
if !has_more {
|
||||
self.agents_overview.reset_visible_pagination();
|
||||
}
|
||||
if !discovery.has_more() {
|
||||
self.agents_overview
|
||||
.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.has_more = has_more;
|
||||
.refill_by_backend
|
||||
.remove(&refresh_backend_id);
|
||||
self.agents_overview
|
||||
.show_more_backends
|
||||
.remove(&refresh_backend_id);
|
||||
}
|
||||
self.agents_overview
|
||||
.discovery
|
||||
.insert(refresh_backend_id, discovery);
|
||||
let has_more = self
|
||||
.agents_overview
|
||||
.has_more_for(&self.backend_registry, app_server.backend_id());
|
||||
self.agents_overview
|
||||
.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.has_more = has_more;
|
||||
}
|
||||
for (thread_id, thread) in refresh.threads {
|
||||
if self.agents_overview.removed_threads.contains(&thread_id) {
|
||||
@@ -256,13 +261,15 @@ impl App {
|
||||
self.agents_overview.usage.remove(&thread_id);
|
||||
continue;
|
||||
}
|
||||
if displayed_refresh
|
||||
&& !self.agents_overview.threads.contains_key(&thread_id)
|
||||
if !self.agents_overview.threads.contains_key(&thread_id)
|
||||
&& !self.agents_overview.hidden_threads.contains(&thread_id)
|
||||
&& is_overview_root(&thread)
|
||||
&& let Some(refill) = self
|
||||
.agents_overview
|
||||
.refill_by_backend
|
||||
.get_mut(&refresh_backend_id)
|
||||
{
|
||||
self.agents_overview.refill_count =
|
||||
self.agents_overview.refill_count.saturating_sub(1);
|
||||
*refill = refill.saturating_sub(1);
|
||||
}
|
||||
self.agents_overview
|
||||
.activity
|
||||
@@ -300,14 +307,116 @@ impl App {
|
||||
self.track_agents_overview_notification(¬ification);
|
||||
}
|
||||
}
|
||||
if std::mem::take(&mut self.agents_overview.refresh_pending)
|
||||
|| invalidated
|
||||
|| (refill_succeeded
|
||||
&& (self.agents_overview.refill_count > 0
|
||||
|| self.agents_overview.show_more_requested)
|
||||
&& self.agents_overview.has_more(app_server.backend_id()))
|
||||
let overview = &mut self.agents_overview;
|
||||
if refill_succeeded {
|
||||
for (&owner, discovery) in &overview.discovery {
|
||||
if owner == app_server.backend_id()
|
||||
&& discovery.has_more()
|
||||
&& (overview.refill_count(owner) > 0
|
||||
|| overview.show_more_backends.contains(&owner))
|
||||
&& !overview.pending_refresh_backends.contains(&owner)
|
||||
{
|
||||
overview.pending_refresh_backends.push_back(owner);
|
||||
}
|
||||
}
|
||||
}
|
||||
self.drain_agents_overview_refresh_queue();
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
|
||||
pub(super) fn drain_agents_overview_refresh_queue(&mut self) {
|
||||
if self.agents_overview.active_refresh.is_some() || self.reconnect.offline {
|
||||
return;
|
||||
}
|
||||
let visible = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some();
|
||||
if let Some((backend_id, handle)) = self
|
||||
.agents_overview
|
||||
.pending_refresh_backends
|
||||
.iter()
|
||||
.copied()
|
||||
.filter(|&backend_id| {
|
||||
self.app_server_backend_id
|
||||
.is_none_or(|owner| owner == backend_id)
|
||||
&& (visible || !self.agents_overview.initialized.contains(&backend_id))
|
||||
})
|
||||
.find_map(|backend_id| {
|
||||
self.backend_registry
|
||||
.request_handle(backend_id)
|
||||
.map(|handle| (backend_id, handle))
|
||||
})
|
||||
{
|
||||
self.refresh_changed_agents_overview_threads(app_server);
|
||||
self.start_agents_overview_refresh_for_backend(backend_id, handle);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn reset_agents_overview_discovery(&mut self, backend_id: BackendId) {
|
||||
let overview = &mut self.agents_overview;
|
||||
overview.initialized.remove(&backend_id);
|
||||
overview.discovery.remove(&backend_id);
|
||||
overview
|
||||
.removed_threads
|
||||
.retain(|thread_id| self.backend_registry.owner(*thread_id) != Some(backend_id));
|
||||
overview
|
||||
.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.has_more = self
|
||||
.app_server_backend_id
|
||||
.is_some_and(|owner| overview.has_more_for(&self.backend_registry, owner));
|
||||
}
|
||||
|
||||
pub(super) fn cancel_agents_overview_refresh(&mut self, backend_id: BackendId) {
|
||||
let overview = &mut self.agents_overview;
|
||||
if overview
|
||||
.active_refresh
|
||||
.is_some_and(|(_, owner)| owner == backend_id)
|
||||
{
|
||||
if let Some(task) = overview.refresh_task.take() {
|
||||
task.abort();
|
||||
}
|
||||
overview.active_refresh = None;
|
||||
overview.refresh_notifications.clear();
|
||||
if std::mem::take(&mut overview.refresh_show_more) {
|
||||
overview.show_more_backends.insert(backend_id);
|
||||
}
|
||||
let removed_threads = &overview.removed_threads;
|
||||
overview.refresh_thread_ids.extend(
|
||||
overview
|
||||
.active_refresh_thread_ids
|
||||
.drain()
|
||||
.filter(|id| !removed_threads.contains(id)),
|
||||
);
|
||||
overview
|
||||
.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.loading = false;
|
||||
}
|
||||
overview
|
||||
.pending_refresh_backends
|
||||
.retain(|id| *id != backend_id);
|
||||
if self.backend_registry.request_handle(backend_id).is_none() {
|
||||
overview.refresh_failed_backends.remove(&backend_id);
|
||||
}
|
||||
self.drain_agents_overview_refresh_queue();
|
||||
{
|
||||
let mut state = self
|
||||
.agents_overview
|
||||
.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
state.has_more = self.app_server_backend_id.is_some_and(|owner| {
|
||||
self.agents_overview
|
||||
.has_more_for(&self.backend_registry, owner)
|
||||
});
|
||||
state.refresh_failed = self.app_server_backend_id.is_some_and(|owner| {
|
||||
self.agents_overview
|
||||
.refresh_failed_backends
|
||||
.contains(&owner)
|
||||
});
|
||||
}
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@ use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
|
||||
use crate::app_event::AgentsOverviewAction;
|
||||
use crate::app_event::AppEvent;
|
||||
use crate::app_server_session::AppServerSession;
|
||||
use crate::backend_id::BackendId;
|
||||
use crate::bottom_pane::SelectionItem;
|
||||
use crate::bottom_pane::SelectionViewParams;
|
||||
use crate::chatwidget::ChatWidget;
|
||||
@@ -107,6 +108,7 @@ impl App {
|
||||
}
|
||||
let request_id = Uuid::new_v4();
|
||||
self.agents_overview.pending_pin_change = Some((request_id, app_server.backend_id()));
|
||||
let backend_id = app_server.backend_id();
|
||||
let request_handle = app_server.request_handle();
|
||||
let app_event_tx = self.app_event_tx.clone();
|
||||
tokio::spawn(async move {
|
||||
@@ -123,6 +125,7 @@ impl App {
|
||||
.map(|_| ())
|
||||
.map_err(|error| error.to_string());
|
||||
app_event_tx.send(AppEvent::AgentsOverviewPinToggled {
|
||||
backend_id,
|
||||
request_id,
|
||||
thread_id,
|
||||
pinned,
|
||||
@@ -134,6 +137,7 @@ impl App {
|
||||
pub(super) fn complete_agents_overview_pin(
|
||||
&mut self,
|
||||
app_server: &AppServerSession,
|
||||
backend_id: BackendId,
|
||||
request_id: Uuid,
|
||||
thread_id: ThreadId,
|
||||
pinned: bool,
|
||||
@@ -142,7 +146,7 @@ impl App {
|
||||
let Some((_, owner)) = self
|
||||
.agents_overview
|
||||
.pending_pin_change
|
||||
.filter(|(id, _)| *id == request_id)
|
||||
.filter(|(id, owner)| *id == request_id && *owner == backend_id)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
@@ -168,21 +172,11 @@ impl App {
|
||||
));
|
||||
}
|
||||
}
|
||||
let restore_show_more = self.agents_overview.refresh_show_more;
|
||||
if let Some(refresh) = self.agents_overview.refresh_task.take() {
|
||||
refresh.abort();
|
||||
self.cancel_agents_overview_refresh(backend_id);
|
||||
if backend_id == app_server.backend_id() {
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
}
|
||||
self.agents_overview.active_refresh = None;
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.refresh_notifications.clear();
|
||||
let refresh_thread_ids =
|
||||
std::mem::take(&mut self.agents_overview.active_refresh_thread_ids);
|
||||
self.agents_overview
|
||||
.refresh_thread_ids
|
||||
.extend(refresh_thread_ids);
|
||||
self.agents_overview.refresh_pending = false;
|
||||
self.agents_overview.show_more_requested |= restore_show_more;
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
|
||||
@@ -375,22 +369,7 @@ impl App {
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.removal = None;
|
||||
let (result, detach_primary) = outcome?;
|
||||
if attempted {
|
||||
// A read started before the RPC can contain stale task and approval state.
|
||||
if let Some(refresh) = self.agents_overview.refresh_task.take() {
|
||||
refresh.abort();
|
||||
}
|
||||
self.agents_overview.active_refresh = None;
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.active_refresh_thread_ids.clear();
|
||||
self.agents_overview
|
||||
.view_state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.loading = false;
|
||||
self.agents_overview.refresh_pending = false;
|
||||
self.agents_overview.refresh_notifications.clear();
|
||||
}
|
||||
|
||||
if result.is_ok() {
|
||||
let mut removed = if removes_subtree {
|
||||
self.known_thread_subtree(thread_id)
|
||||
@@ -413,6 +392,10 @@ impl App {
|
||||
self.agents_overview.dispatched_requests.remove(&removed_id);
|
||||
}
|
||||
}
|
||||
if attempted {
|
||||
// Discard reads started before the mutation after recording the removed threads.
|
||||
self.cancel_agents_overview_refresh(app_server.backend_id());
|
||||
}
|
||||
if detach_primary {
|
||||
self.agents_overview.selection_after_removal =
|
||||
self.agents_overview.selection_after_removal.or_else(|| {
|
||||
|
||||
@@ -5,6 +5,7 @@ use crate::app_event::AgentsOverviewAction;
|
||||
use codex_app_server_protocol::ClientRequest;
|
||||
use codex_app_server_protocol::RequestId;
|
||||
use codex_app_server_protocol::ThreadLoadedListParams;
|
||||
use codex_app_server_protocol::ThreadStatusChangedNotification;
|
||||
use codex_app_server_protocol::TurnStartParams;
|
||||
use codex_app_server_protocol::TurnStartResponse;
|
||||
use codex_model_provider_info::ModelProviderInfo;
|
||||
@@ -21,9 +22,28 @@ async fn pin_action_updates_shared_section_state() -> Result<()> {
|
||||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||||
let started = app_server.start_thread(&app.config).await?;
|
||||
let thread_id = started.session.thread_id;
|
||||
attach_thread(&mut app, thread_id);
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
app.backend_registry.connect(&app_server);
|
||||
app.open_agents_overview(&app_server);
|
||||
finish_overview_refresh(&mut app, &app_server, &mut rx).await;
|
||||
|
||||
let status_changed = |status| {
|
||||
ServerNotification::ThreadStatusChanged(ThreadStatusChangedNotification {
|
||||
thread_id: thread_id.to_string(),
|
||||
status,
|
||||
})
|
||||
};
|
||||
for pinned in [true, false] {
|
||||
app.refresh_agents_overview_threads(&app_server);
|
||||
app.track_agents_overview_notification(&status_changed(ThreadStatus::Active {
|
||||
active_flags: Vec::new(),
|
||||
}));
|
||||
assert!(
|
||||
app.agents_overview
|
||||
.refresh_notifications
|
||||
.contains_key(&thread_id)
|
||||
);
|
||||
Box::pin(app.handle_event(
|
||||
&mut tui,
|
||||
&mut app_server,
|
||||
@@ -34,6 +54,12 @@ async fn pin_action_updates_shared_section_state() -> Result<()> {
|
||||
.agents_overview
|
||||
.pending_pin_change
|
||||
.expect("pin request started");
|
||||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||||
assert!(
|
||||
app.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_none()
|
||||
);
|
||||
let completed = tokio::time::timeout(std::time::Duration::from_secs(15), async {
|
||||
loop {
|
||||
let event = rx.recv().await.expect("pin request completes");
|
||||
@@ -45,12 +71,19 @@ async fn pin_action_updates_shared_section_state() -> Result<()> {
|
||||
}
|
||||
})
|
||||
.await?;
|
||||
app.agents_overview
|
||||
.refresh_notifications
|
||||
.insert(thread_id, Vec::new());
|
||||
Box::pin(app.handle_event(&mut tui, &mut app_server, completed)).await?;
|
||||
assert_eq!(app.agents_overview.pending_pin_change, None);
|
||||
assert!(app.agents_overview.refresh_notifications.is_empty());
|
||||
assert_eq!(app.agents_overview.active_refresh, None);
|
||||
app.track_agents_overview_notification(&status_changed(ThreadStatus::Idle));
|
||||
app.open_agents_overview(&app_server);
|
||||
finish_overview_refresh(&mut app, &app_server, &mut rx).await;
|
||||
assert_eq!(
|
||||
app.agents_overview.threads[&thread_id]
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.status,
|
||||
ThreadStatus::Idle
|
||||
);
|
||||
let threads = list_pinned_threads(&app_server.request_handle())
|
||||
.await
|
||||
.map_err(color_eyre::eyre::Report::msg)?
|
||||
@@ -181,6 +214,44 @@ async fn cloud_archive_preserves_attached_child_and_other_tasks() -> Result<()>
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pin_completion_cancels_the_originating_backends_stale_refresh() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||||
let backend_id = BackendId::new();
|
||||
let thread_id = ThreadId::new();
|
||||
app.backend_registry.observe(backend_id, thread_id);
|
||||
app.agents_overview
|
||||
.pins_by_backend
|
||||
.insert(backend_id, Some(Vec::new()));
|
||||
let pin_request = Uuid::new_v4();
|
||||
app.agents_overview.pending_pin_change = Some((pin_request, backend_id));
|
||||
let stale_refresh = Uuid::new_v4();
|
||||
app.agents_overview.active_refresh = Some((stale_refresh, backend_id));
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
|
||||
Box::pin(app.handle_event(
|
||||
&mut tui,
|
||||
&mut app_server,
|
||||
AppEvent::AgentsOverviewPinToggled {
|
||||
backend_id,
|
||||
request_id: pin_request,
|
||||
thread_id,
|
||||
pinned: true,
|
||||
result: Ok(()),
|
||||
},
|
||||
))
|
||||
.await?;
|
||||
|
||||
assert_eq!(app.agents_overview.active_refresh, None);
|
||||
assert_eq!(
|
||||
app.agents_overview.pins_by_backend[&backend_id],
|
||||
Some(vec![thread_id])
|
||||
);
|
||||
app_server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn archive_confirmation_number_keys_act_immediately() {
|
||||
for key in ['1', '2'] {
|
||||
@@ -977,6 +1048,7 @@ async fn lifecycle_removes_background_and_current_tasks_without_losing_the_dashb
|
||||
};
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
tui.pause_events();
|
||||
app.backend_registry.connect(&app_server);
|
||||
app.open_agents_overview(&app_server);
|
||||
if action == AgentsOverviewAction::Archive {
|
||||
let rollout = app_server
|
||||
|
||||
@@ -214,6 +214,9 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
|
||||
crate::connect_remote_app_server(endpoint).await?,
|
||||
ThreadParamsMode::Remote,
|
||||
);
|
||||
let owner = session.backend_id();
|
||||
app.app_server_backend_id = Some(owner);
|
||||
app.backend_registry.connect(&session);
|
||||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
@@ -225,7 +228,10 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
|
||||
app.agents_overview.pins_by_backend[&session.backend_id()],
|
||||
Some(vec![ids[1]])
|
||||
);
|
||||
assert!(app.agents_overview.has_more(session.backend_id()));
|
||||
assert!(
|
||||
app.agents_overview
|
||||
.has_more_for(&app.backend_registry, owner)
|
||||
);
|
||||
let browse = app.agents_overview.threads.clone();
|
||||
let browse_rows = || browse.values().flatten().cloned().collect();
|
||||
let mut view = app.agents_overview_view(browse_rows(), Some(ids[4]));
|
||||
@@ -259,6 +265,11 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
|
||||
assert!(rendered.contains("1 of 10"), "{rendered}"); // The pinned task has its own group.
|
||||
view.handle_key_event(KeyCode::Esc.into());
|
||||
|
||||
if mixed_sources {
|
||||
// Queue Show more behind a metadata refresh before the archive creates a vacancy.
|
||||
app.refresh_agents_overview_threads(&session);
|
||||
app.show_more_agents_overview(&session);
|
||||
}
|
||||
app.track_agents_overview_notification(&ServerNotification::ThreadArchived(
|
||||
ThreadArchivedNotification {
|
||||
thread_id: ids[0].to_string(),
|
||||
@@ -268,7 +279,9 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
|
||||
expected.remove(&ids[0]);
|
||||
app.refresh_agents_overview_threads(&session);
|
||||
finish_overview_refresh(&mut app, &session, &mut rx).await;
|
||||
if !mixed_sources {
|
||||
if mixed_sources {
|
||||
finish_overview_refresh(&mut app, &session, &mut rx).await;
|
||||
} else {
|
||||
assert_eq!(app.agents_overview.threads.len(), 9);
|
||||
assert!(
|
||||
app.agents_overview
|
||||
@@ -283,31 +296,51 @@ 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 other = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||||
let other_owner = other.backend_id();
|
||||
if mixed_sources {
|
||||
let archived = ids[22];
|
||||
app.backend_registry.observe(session.backend_id(), archived);
|
||||
app.backend_registry.observe(owner, archived);
|
||||
app.track_agents_overview_notification(&ServerNotification::ThreadArchived(
|
||||
ThreadArchivedNotification {
|
||||
thread_id: archived.to_string(),
|
||||
},
|
||||
));
|
||||
expected.remove(&archived);
|
||||
} else {
|
||||
app.show_more_agents_overview(&session);
|
||||
}
|
||||
app.agents_overview.reset_visible_pagination();
|
||||
assert!(
|
||||
app.agents_overview.active_refresh.is_some(),
|
||||
"Show more should load a page after the vacancy is filled"
|
||||
);
|
||||
assert_eq!(
|
||||
app.agents_overview.active_refresh.map(|(_, owner)| owner),
|
||||
Some(owner)
|
||||
);
|
||||
// The page may finish while another backend is displayed, or after returning.
|
||||
app.app_server_backend_id = Some(other_owner);
|
||||
app.backend_registry.connect(&other);
|
||||
assert!(app.backend_registry.request_handle(owner).is_some());
|
||||
assert!(
|
||||
!app.agents_overview
|
||||
.has_more_for(&app.backend_registry, other_owner)
|
||||
);
|
||||
app.show_more_agents_overview(&other);
|
||||
assert!(app.agents_overview.pending_refresh_backends.is_empty());
|
||||
if mixed_sources {
|
||||
app.refresh_agents_overview_threads(&other);
|
||||
finish_overview_refresh(&mut app, &other, &mut rx).await;
|
||||
}
|
||||
app.agents_overview.reset_visible_pagination();
|
||||
app.show_more_agents_overview(&session);
|
||||
// The page may finish while another backend is displayed, or after returning.
|
||||
app.agents_overview.reset_visible_pagination();
|
||||
finish_overview_refresh(&mut app, &other, &mut rx).await;
|
||||
if mixed_sources {
|
||||
finish_overview_refresh(&mut app, &session, &mut rx).await;
|
||||
} else {
|
||||
finish_overview_refresh(&mut app, &other, &mut rx).await;
|
||||
app.agents_overview.reset_visible_pagination();
|
||||
assert!(app.agents_overview.initialized.contains(&other_owner));
|
||||
}
|
||||
app.app_server_backend_id = Some(owner);
|
||||
assert!(
|
||||
app.agents_overview
|
||||
.has_more_for(&app.backend_registry, owner)
|
||||
);
|
||||
app.backend_registry.disconnect(other_owner);
|
||||
other.shutdown().await?;
|
||||
assert_eq!(
|
||||
app.agents_overview
|
||||
@@ -334,7 +367,10 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
|
||||
app.refresh_agents_overview_threads(&session);
|
||||
finish_overview_refresh(&mut app, &session, &mut rx).await;
|
||||
assert_eq!(app.agents_overview.threads, expected);
|
||||
assert!(!app.agents_overview.has_more(session.backend_id()));
|
||||
assert!(
|
||||
!app.agents_overview
|
||||
.has_more_for(&app.backend_registry, owner)
|
||||
);
|
||||
let old = app.agents_overview.threads[&ids[23]].as_ref().unwrap();
|
||||
assert_eq!(old.preview, "Task 23");
|
||||
assert_eq!(
|
||||
@@ -356,7 +392,7 @@ async fn check_discovery(mixed_sources: bool) -> Result<()> {
|
||||
view.handle_key_event(KeyCode::Esc.into());
|
||||
app.agents_overview.threads.clear();
|
||||
app.agents_overview.pins_by_backend = [(session.backend_id(), Some(Vec::new()))].into();
|
||||
app.agents_overview.refill_count = 0;
|
||||
app.agents_overview.refill_by_backend.clear();
|
||||
app.refresh_agents_overview_threads(&session);
|
||||
finish_overview_refresh(&mut app, &session, &mut rx).await;
|
||||
assert_eq!(
|
||||
|
||||
@@ -293,6 +293,102 @@ async fn overview_opens_a_search_only_task_on_the_search_backend() -> Result<()>
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn late_overview_page_only_refills_its_own_backend() {
|
||||
let mut app = make_test_app().await;
|
||||
let displayed = BackendId::new();
|
||||
let other = BackendId::new();
|
||||
let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1);
|
||||
let session = AppServerSession::new(
|
||||
displayed,
|
||||
AppServerClient::Cloud(client),
|
||||
ThreadParamsMode::Cloud,
|
||||
);
|
||||
app.app_server_backend_id = Some(displayed);
|
||||
let id = ThreadId::new();
|
||||
assert!(app.backend_registry.observe(displayed, id));
|
||||
app.agents_overview.threads.insert(
|
||||
id,
|
||||
Some(overview_thread(
|
||||
id,
|
||||
/*parent_thread_id*/ None,
|
||||
"Removed",
|
||||
ThreadStatus::Idle,
|
||||
)),
|
||||
);
|
||||
app.remove_agents_overview_thread(id);
|
||||
|
||||
for owner in [other, displayed] {
|
||||
let request_id = Uuid::new_v4();
|
||||
let replacement = ThreadId::new();
|
||||
let row = overview_thread(
|
||||
replacement,
|
||||
/*parent_thread_id*/ None,
|
||||
"Replacement",
|
||||
ThreadStatus::Idle,
|
||||
);
|
||||
app.agents_overview.active_refresh = Some((request_id, owner));
|
||||
app.apply_agents_overview_thread_refresh(
|
||||
&session,
|
||||
request_id,
|
||||
Ok(AgentsOverviewThreadRefresh {
|
||||
cleared_unread: Vec::new(),
|
||||
threads: HashMap::from([(replacement, Some((row, false, None)))]),
|
||||
last_messages: HashMap::new(),
|
||||
recent_seed_complete: true,
|
||||
discovery: None,
|
||||
pinned_thread_ids: None,
|
||||
}),
|
||||
);
|
||||
assert_eq!(app.agents_overview.refill_count(other), 0);
|
||||
assert_eq!(
|
||||
app.agents_overview.refill_count(displayed),
|
||||
usize::from(owner != displayed)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn queued_overview_page_survives_a_focus_change() {
|
||||
let mut app = make_test_app().await;
|
||||
let owner = BackendId::new();
|
||||
let other = BackendId::new();
|
||||
let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1);
|
||||
let session = AppServerSession::new(
|
||||
owner,
|
||||
AppServerClient::Cloud(client),
|
||||
ThreadParamsMode::Cloud,
|
||||
);
|
||||
app.backend_registry.connect(&session);
|
||||
app.app_server_backend_id = Some(owner);
|
||||
app.agents_overview.initialized.insert(owner);
|
||||
app.agents_overview
|
||||
.discovery
|
||||
.insert(owner, Default::default());
|
||||
app.agents_overview.active_refresh = Some((Uuid::new_v4(), other));
|
||||
app.open_agents_overview(&session);
|
||||
app.show_more_agents_overview(&session);
|
||||
|
||||
app.app_server_backend_id = Some(other);
|
||||
app.agents_overview.active_refresh = None;
|
||||
app.drain_agents_overview_refresh_queue();
|
||||
assert_eq!(
|
||||
app.agents_overview.pending_refresh_backends.front(),
|
||||
Some(&owner)
|
||||
);
|
||||
assert!(app.agents_overview.active_refresh.is_none());
|
||||
|
||||
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());
|
||||
assert!(app.agents_overview.refresh_show_more);
|
||||
app.cancel_agents_overview_refresh(owner);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
@@ -315,6 +411,7 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> {
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
app.app_event_tx = AppEventSender::new(tx);
|
||||
app.app_server_backend_id = Some(displayed.backend_id());
|
||||
app.backend_registry.connect(&displayed);
|
||||
let local_reads = HashMap::from([(local_id, Some((local, false, None))), (remote_id, None)]);
|
||||
let remote_reads = HashMap::from([
|
||||
(remote_id, Some((remote.clone(), false, None))),
|
||||
@@ -347,7 +444,7 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> {
|
||||
threads: reads,
|
||||
last_messages: HashMap::new(),
|
||||
recent_seed_complete: owner == remote_owner,
|
||||
discovery: (owner != displayed.backend_id()).then(Default::default),
|
||||
discovery: (owner == remote_owner).then(Default::default),
|
||||
pinned_thread_ids: Some(pins),
|
||||
}),
|
||||
);
|
||||
@@ -471,6 +568,37 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn overview_hides_show_more_when_only_paginated_backend_disconnects() {
|
||||
let mut app = make_test_app().await;
|
||||
let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1);
|
||||
let session = AppServerSession::new(
|
||||
BackendId::new(),
|
||||
AppServerClient::Cloud(client),
|
||||
crate::app_server_session::ThreadParamsMode::Cloud,
|
||||
);
|
||||
let owner = session.backend_id();
|
||||
app.backend_registry.connect(&session);
|
||||
app.agents_overview
|
||||
.discovery
|
||||
.insert(owner, Default::default());
|
||||
app.agents_overview.view_state.lock().unwrap().has_more = true;
|
||||
|
||||
app.backend_registry.disconnect(owner);
|
||||
app.cancel_agents_overview_refresh(owner);
|
||||
app.reconnect.offline = true;
|
||||
app.open_agents_overview(&session);
|
||||
|
||||
assert!(app.backend_registry.request_handle(owner).is_none());
|
||||
assert!(
|
||||
!app.agents_overview
|
||||
.has_more_for(&app.backend_registry, owner)
|
||||
);
|
||||
assert!(!app.agents_overview.view_state.lock().unwrap().has_more);
|
||||
app.show_more_agents_overview(&session);
|
||||
assert!(app.agents_overview.active_refresh.is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn overview_right_opens_current_or_highlighted_task() {
|
||||
let mut app = make_test_app().await;
|
||||
@@ -605,7 +733,7 @@ pub(in crate::app) fn overview_thread(
|
||||
|
||||
#[tokio::test]
|
||||
async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
let (mut app, mut events, _) = make_test_app_with_channels().await;
|
||||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
let [retained, archived, deleted, created] = std::array::from_fn(|_| ThreadId::new());
|
||||
@@ -770,6 +898,46 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re
|
||||
assert!(app.agents_overview.activity.contains_key(&retained));
|
||||
assert!(app.agents_overview.active_refresh.is_none());
|
||||
}
|
||||
|
||||
// Archive a retained task while its metadata refresh is in flight, then lose events.
|
||||
app.backend_registry.connect(&app_server);
|
||||
app.refresh_agents_overview_threads(&app_server);
|
||||
let interrupted_request = app.agents_overview.active_refresh.unwrap().0;
|
||||
app.handle_app_server_event(
|
||||
&app_server,
|
||||
AppServerEvent::ServerNotification(Box::new(ServerNotification::ThreadArchived(
|
||||
ThreadArchivedNotification {
|
||||
thread_id: retained.to_string(),
|
||||
},
|
||||
))),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(
|
||||
app.agents_overview.active_refresh.map(|(id, _)| id),
|
||||
Some(interrupted_request)
|
||||
);
|
||||
assert!(app.agents_overview.removed_threads.contains(&retained));
|
||||
assert!(
|
||||
app.agents_overview
|
||||
.active_refresh_thread_ids
|
||||
.contains(&retained)
|
||||
);
|
||||
|
||||
app.handle_app_server_event(&app_server, AppServerEvent::Lagged { skipped: 1 })
|
||||
.await;
|
||||
let restarted_request = app
|
||||
.agents_overview
|
||||
.active_refresh
|
||||
.expect("lag starts a replacement refresh")
|
||||
.0;
|
||||
assert_ne!(restarted_request, interrupted_request);
|
||||
// Check the replacement read targets before applying any results.
|
||||
assert_eq!(
|
||||
app.agents_overview.active_refresh_thread_ids,
|
||||
HashSet::from([created])
|
||||
);
|
||||
finish_overview_refresh(&mut app, &app_server, &mut events).await;
|
||||
assert!(!app.agents_overview.threads.contains_key(&retained));
|
||||
app_server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -851,6 +1019,7 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res
|
||||
};
|
||||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
app.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);
|
||||
app.backend_registry.connect(&app_server);
|
||||
app.refresh_agents_overview_threads(&app_server);
|
||||
finish_overview_refresh(&mut app, &app_server, &mut event_rx).await;
|
||||
let recent_ids: HashSet<_> = ids[2..].iter().copied().collect();
|
||||
@@ -941,6 +1110,7 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res
|
||||
let app_server = Box::pin(crate::start_embedded_app_server_for_picker(&config)).await?;
|
||||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
restarted.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);
|
||||
restarted.backend_registry.connect(&app_server);
|
||||
restarted.refresh_agents_overview_threads(&app_server);
|
||||
finish_overview_refresh(&mut restarted, &app_server, &mut event_rx).await;
|
||||
let retained: HashSet<_> = restarted.agents_overview.threads.keys().copied().collect();
|
||||
@@ -953,7 +1123,11 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res
|
||||
"agents_overview_recent_sessions",
|
||||
age.replace_all(&rendered, " [age]")
|
||||
);
|
||||
assert!(restarted.agents_overview.has_more(app_server.backend_id()));
|
||||
assert!(
|
||||
restarted
|
||||
.agents_overview
|
||||
.has_more_for(&restarted.backend_registry, app_server.backend_id())
|
||||
);
|
||||
// Opening starts a metadata refresh; Show more queues behind it.
|
||||
restarted.show_more_agents_overview(&app_server);
|
||||
finish_overview_refresh(&mut restarted, &app_server, &mut event_rx).await;
|
||||
@@ -967,7 +1141,11 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res
|
||||
.collect::<HashSet<_>>(),
|
||||
ids.into_iter().collect()
|
||||
);
|
||||
assert!(!restarted.agents_overview.has_more(app_server.backend_id()));
|
||||
assert!(
|
||||
!restarted
|
||||
.agents_overview
|
||||
.has_more_for(&restarted.backend_registry, app_server.backend_id())
|
||||
);
|
||||
app_server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -1046,7 +1224,9 @@ async fn check_hidden_thread_does_not_refresh_shared_overview(source: &str) {
|
||||
assert_eq!(
|
||||
(
|
||||
app.agents_overview.active_refresh.map(|(id, _)| id),
|
||||
app.agents_overview.refresh_pending,
|
||||
app.agents_overview
|
||||
.pending_refresh_backends
|
||||
.contains(&app_server.backend_id()),
|
||||
),
|
||||
(Some(request_id), false)
|
||||
);
|
||||
@@ -1077,7 +1257,9 @@ async fn check_hidden_thread_does_not_refresh_shared_overview(source: &str) {
|
||||
assert_eq!(
|
||||
(
|
||||
app.agents_overview.active_refresh.map(|(id, _)| id),
|
||||
app.agents_overview.refresh_pending,
|
||||
app.agents_overview
|
||||
.pending_refresh_backends
|
||||
.contains(&app_server.backend_id()),
|
||||
),
|
||||
(Some(request_id), true)
|
||||
);
|
||||
@@ -3370,7 +3552,7 @@ async fn command_center_refresh_failure_is_inline_and_clears_on_success() -> Res
|
||||
threads: HashMap::new(),
|
||||
last_messages: HashMap::new(),
|
||||
recent_seed_complete: true,
|
||||
discovery: None,
|
||||
discovery: Some(Default::default()),
|
||||
pinned_thread_ids: None,
|
||||
}),
|
||||
);
|
||||
|
||||
@@ -1,10 +1,13 @@
|
||||
//! Retains overview membership for this TUI, independently of server subscriptions.
|
||||
//! A bounded recent seed runs at startup, after reconnect, and after event lag.
|
||||
//! 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;
|
||||
@@ -12,7 +15,9 @@ 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;
|
||||
@@ -28,6 +33,7 @@ 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;
|
||||
@@ -58,21 +64,37 @@ impl App {
|
||||
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_count += 1;
|
||||
*self
|
||||
.agents_overview
|
||||
.refill_by_backend
|
||||
.entry(owner)
|
||||
.or_default() += 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn show_more_agents_overview(&mut self, app_server: &AppServerSession) {
|
||||
if !self.agents_overview.has_more(app_server.backend_id()) {
|
||||
return;
|
||||
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);
|
||||
}
|
||||
self.agents_overview.show_more_requested |= self.agents_overview.refill_count == 0;
|
||||
self.start_agents_overview_refresh(app_server);
|
||||
}
|
||||
|
||||
pub(super) fn track_agents_overview_notification(&mut self, notification: &ServerNotification) {
|
||||
@@ -253,13 +275,41 @@ impl App {
|
||||
{
|
||||
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();
|
||||
let initialized = self.agents_overview.initialized.contains(&backend_id);
|
||||
let source_has_more = self.agents_overview.has_more(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)
|
||||
@@ -267,24 +317,33 @@ impl App {
|
||||
if !visible && initialized {
|
||||
return;
|
||||
}
|
||||
if self.agents_overview.active_refresh.is_some() {
|
||||
self.agents_overview.refresh_pending = true;
|
||||
if overview.active_refresh.is_some() {
|
||||
if !overview.pending_refresh_backends.contains(&backend_id) {
|
||||
overview.pending_refresh_backends.push_back(backend_id);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if initialized
|
||||
&& self.agents_overview.refresh_thread_ids.is_empty()
|
||||
&& !self.agents_overview.show_more_requested
|
||||
&& !(self.agents_overview.refill_count > 0 && source_has_more)
|
||||
&& !self.agents_overview.pin_refresh_requested
|
||||
{
|
||||
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 owns_thread = |thread_id| {
|
||||
self.backend_registry
|
||||
.owner(thread_id)
|
||||
.is_none_or(|owner| owner == backend_id)
|
||||
};
|
||||
let mut unread_rows = Vec::new();
|
||||
if std::mem::take(&mut self.agents_overview.pin_refresh_requested) {
|
||||
unread_rows.extend(
|
||||
@@ -292,15 +351,20 @@ impl App {
|
||||
.visible_thread_ids
|
||||
.iter()
|
||||
.copied()
|
||||
.filter(|id| self.agents_overview.unread.contains(id) && owns_thread(*id)),
|
||||
.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));
|
||||
self.agents_overview.refresh_invalidated = false;
|
||||
let refill = self.agents_overview.refill_count;
|
||||
let show_more =
|
||||
refill == 0 && std::mem::take(&mut self.agents_overview.show_more_requested);
|
||||
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 {
|
||||
@@ -309,23 +373,24 @@ impl App {
|
||||
10
|
||||
};
|
||||
let mut discovery = discover.then(|| {
|
||||
if initialized {
|
||||
self.agents_overview
|
||||
.discovery
|
||||
.get(&backend_id)
|
||||
.cloned()
|
||||
.unwrap_or_default()
|
||||
} else {
|
||||
self.agents_overview
|
||||
.removed_threads
|
||||
.retain(|id| !owns_thread(*id));
|
||||
Default::default()
|
||||
}
|
||||
self.agents_overview
|
||||
.discovery
|
||||
.get(&backend_id)
|
||||
.cloned()
|
||||
.unwrap_or_default()
|
||||
});
|
||||
let mut thread_ids = std::mem::take(&mut self.agents_overview.refresh_thread_ids);
|
||||
thread_ids.retain(|id| owns_thread(*id));
|
||||
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 request_handle = app_server.request_handle();
|
||||
let app_event_tx = self.app_event_tx.clone();
|
||||
self.agents_overview
|
||||
.view_state
|
||||
|
||||
@@ -76,19 +76,24 @@ impl App {
|
||||
"app-server event consumer lagged; dropping ignored events"
|
||||
);
|
||||
self.chat_widget.finish_mcp_startup_after_lag();
|
||||
if let Some(task) = self.agents_overview.refresh_task.take() {
|
||||
task.abort();
|
||||
}
|
||||
self.agents_overview.active_refresh = None;
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.active_refresh_thread_ids.clear();
|
||||
self.agents_overview.refresh_pending = false;
|
||||
let owner = app_server_client.backend_id();
|
||||
self.cancel_agents_overview_refresh(owner);
|
||||
self.reset_agents_overview_discovery(owner);
|
||||
let registry = &self.backend_registry;
|
||||
let belongs_to_other =
|
||||
|id: &ThreadId| registry.owner(*id).is_some_and(|known| known != owner);
|
||||
self.agents_overview
|
||||
.invalidate_discovery(app_server_client.backend_id(), /*displayed*/ true);
|
||||
self.agents_overview.refresh_notifications.clear();
|
||||
self.agents_overview.activity.clear();
|
||||
self.agents_overview.last_messages.clear();
|
||||
self.agents_overview.usage.clear();
|
||||
.refresh_notifications
|
||||
.retain(|id, _| belongs_to_other(id));
|
||||
self.agents_overview
|
||||
.activity
|
||||
.retain(|id, _| belongs_to_other(id));
|
||||
self.agents_overview
|
||||
.last_messages
|
||||
.retain(|id, _| belongs_to_other(id));
|
||||
self.agents_overview
|
||||
.usage
|
||||
.retain(|id, _| belongs_to_other(id));
|
||||
self.agents_overview.pending_usage = None;
|
||||
self.agents_overview.usage_disabled = false;
|
||||
self.repaint_agents_overview();
|
||||
@@ -398,8 +403,9 @@ impl App {
|
||||
return;
|
||||
}
|
||||
ServerNotification::AccountUpdated(notification) => {
|
||||
self.agents_overview
|
||||
.invalidate_discovery(app_server_client.backend_id(), /*displayed*/ true);
|
||||
let owner = app_server_client.backend_id();
|
||||
self.cancel_agents_overview_refresh(owner);
|
||||
self.reset_agents_overview_discovery(owner);
|
||||
self.refresh_changed_agents_overview_threads(app_server_client);
|
||||
self.agents_overview.usage.clear();
|
||||
self.agents_overview.pending_usage = None;
|
||||
|
||||
@@ -37,8 +37,8 @@ impl App {
|
||||
_ => false,
|
||||
};
|
||||
if invalidates_discovery {
|
||||
self.agents_overview
|
||||
.invalidate_discovery(event.backend_id, /*displayed*/ false);
|
||||
self.cancel_agents_overview_refresh(event.backend_id);
|
||||
self.reset_agents_overview_discovery(event.backend_id);
|
||||
}
|
||||
if let AppServerEvent::ServerNotification(notification) = &event.event
|
||||
&& let ServerNotificationThreadTarget::Thread(thread_id) =
|
||||
@@ -51,10 +51,7 @@ impl App {
|
||||
| ServerNotification::ThreadUnarchived(_)
|
||||
) && self.backend_registry.owner(thread_id) == Some(event.backend_id)
|
||||
{
|
||||
// A parked removal must not consume the displayed backend's page budget.
|
||||
let refill_count = self.agents_overview.refill_count;
|
||||
self.track_agents_overview_notification(notification);
|
||||
self.agents_overview.refill_count = refill_count;
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
if let ServerNotification::ThreadSettingsUpdated(settings) = notification.as_ref()
|
||||
|
||||
@@ -1,14 +1,17 @@
|
||||
//! Tracks conversation ownership across backends.
|
||||
//! Tracks conversation ownership and the live request handle for each backend.
|
||||
//! A thread ID keeps its first observed owner across connection replacement.
|
||||
|
||||
use crate::app_server_session::AppServerSession;
|
||||
use crate::app_server_session::AppServerStartedThread;
|
||||
use crate::backend_id::BackendId;
|
||||
use codex_app_server_client::AppServerRequestHandle;
|
||||
use codex_protocol::ThreadId;
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct BackendRegistry {
|
||||
owners: HashMap<ThreadId, BackendId>,
|
||||
connections: HashMap<BackendId, AppServerRequestHandle>,
|
||||
}
|
||||
|
||||
impl BackendRegistry {
|
||||
@@ -35,4 +38,17 @@ impl BackendRegistry {
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
pub(super) fn connect(&mut self, session: &AppServerSession) {
|
||||
self.connections
|
||||
.insert(session.backend_id(), session.request_handle());
|
||||
}
|
||||
|
||||
pub(super) fn disconnect(&mut self, owner: BackendId) {
|
||||
self.connections.remove(&owner);
|
||||
}
|
||||
|
||||
pub(super) fn request_handle(&self, owner: BackendId) -> Option<AppServerRequestHandle> {
|
||||
self.connections.get(&owner).cloned()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -467,16 +467,19 @@ impl App {
|
||||
self.agents_overview.pending_usage = None;
|
||||
self.reset_agents_overview_usage_for_backend_switch();
|
||||
self.agents_overview.usage_disabled = false;
|
||||
self.agents_overview.reset_visible_pagination();
|
||||
self.app_event_tx = AppEventSender::new(self.app_event_tx.app_event_tx.clone());
|
||||
self.app_server_backend_id = Some(destination.backend_id());
|
||||
self.app_server_target = target;
|
||||
self.reconnect = Default::default();
|
||||
if let Ok(mut state) = self.agents_overview.view_state.lock() {
|
||||
state.connection_notice = None;
|
||||
let destination_id = destination.backend_id();
|
||||
state.has_more = self.agents_overview.initialized.contains(&destination_id)
|
||||
&& self.agents_overview.has_more(destination_id);
|
||||
state.has_more = self
|
||||
.agents_overview
|
||||
.has_more_for(&self.backend_registry, destination.backend_id());
|
||||
state.refresh_failed = self
|
||||
.agents_overview
|
||||
.refresh_failed_backends
|
||||
.contains(&destination.backend_id());
|
||||
state.restart_history_search();
|
||||
}
|
||||
self.rate_limit_hard_stop_generation = self.rate_limit_hard_stop_generation.wrapping_add(1);
|
||||
|
||||
@@ -104,6 +104,9 @@ impl App {
|
||||
| AppEvent::ManagedWorktreeCreated(_)
|
||||
| AppEvent::AgentsOverviewWorktreeCreated(_)
|
||||
| AppEvent::AgentsOverviewPinToggled { .. }
|
||||
| AppEvent::OpenAgentsOverview
|
||||
| AppEvent::ShowMoreAgentsOverview
|
||||
| AppEvent::AgentsOverviewThreadsLoaded { .. }
|
||||
| AppEvent::AgentsOverviewUsageLoaded { .. }
|
||||
| AppEvent::AppendMessageHistoryEntry { .. }
|
||||
| AppEvent::BeginInitialHistoryReplayBuffer
|
||||
@@ -3382,13 +3385,14 @@ impl App {
|
||||
self.toggle_agents_overview_pin(app_server, thread_id, pinned);
|
||||
}
|
||||
AppEvent::AgentsOverviewPinToggled {
|
||||
backend_id,
|
||||
request_id,
|
||||
thread_id,
|
||||
pinned,
|
||||
result,
|
||||
} => {
|
||||
self.complete_agents_overview_pin(
|
||||
app_server, request_id, thread_id, pinned, result,
|
||||
app_server, backend_id, request_id, thread_id, pinned, result,
|
||||
);
|
||||
}
|
||||
AppEvent::SuggestThreadName {
|
||||
|
||||
@@ -270,24 +270,40 @@ impl App {
|
||||
self.overlay = None;
|
||||
self.commit_animation = None;
|
||||
self.clear_recap_request(crate::app_event::RecapTrigger::Manual);
|
||||
if let Some(task) = self.agents_overview.refresh_task.take() {
|
||||
task.abort();
|
||||
}
|
||||
self.agents_overview.active_refresh = None;
|
||||
if let Some(owner) = self.app_server_backend_id {
|
||||
let displayed_backend = self.displayed_conversation_backend_id();
|
||||
if let Some(backend_id) = displayed_backend {
|
||||
self.backend_registry.disconnect(backend_id);
|
||||
self.cancel_agents_overview_refresh(backend_id);
|
||||
self.reset_agents_overview_discovery(backend_id);
|
||||
let registry = &self.backend_registry;
|
||||
let other_backend =
|
||||
|id: &ThreadId| registry.owner(*id).is_some_and(|owner| owner != backend_id);
|
||||
self.agents_overview
|
||||
.invalidate_discovery(owner, /*displayed*/ true);
|
||||
.refresh_notifications
|
||||
.retain(|id, _| other_backend(id));
|
||||
self.agents_overview.usage.retain(|id, _| other_backend(id));
|
||||
self.agents_overview
|
||||
.activity
|
||||
.retain(|id, _| other_backend(id));
|
||||
self.agents_overview
|
||||
.last_messages
|
||||
.retain(|id, _| other_backend(id));
|
||||
} else {
|
||||
if let Some(task) = self.agents_overview.refresh_task.take() {
|
||||
task.abort();
|
||||
}
|
||||
self.agents_overview.active_refresh = None;
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.active_refresh_thread_ids.clear();
|
||||
self.agents_overview.pending_refresh_backends.clear();
|
||||
self.agents_overview.refresh_notifications.clear();
|
||||
self.agents_overview.usage.clear();
|
||||
self.agents_overview.activity.clear();
|
||||
self.agents_overview.last_messages.clear();
|
||||
}
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.active_refresh_thread_ids.clear();
|
||||
self.agents_overview.refresh_pending = false;
|
||||
self.agents_overview.refresh_notifications.clear();
|
||||
self.agents_overview.pending_pin_change = None;
|
||||
self.agents_overview.pending_usage = None;
|
||||
self.agents_overview.usage_disabled = false;
|
||||
self.agents_overview.usage.clear();
|
||||
self.agents_overview.activity.clear();
|
||||
self.agents_overview.last_messages.clear();
|
||||
self.reconnect.presentation = if self
|
||||
.chat_widget
|
||||
.selected_index_for_active_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
|
||||
@@ -470,10 +486,9 @@ impl App {
|
||||
cancellation.cancel();
|
||||
}
|
||||
self.agents_overview.dispatched_requests.clear();
|
||||
self.agents_overview.active_refresh = None;
|
||||
self.agents_overview.refresh_show_more = false;
|
||||
self.agents_overview.active_refresh_thread_ids.clear();
|
||||
self.agents_overview.refresh_pending = false;
|
||||
if let Some((_, owner)) = self.agents_overview.active_refresh {
|
||||
self.cancel_agents_overview_refresh(owner);
|
||||
}
|
||||
for input in self.agents_overview.input_states.values_mut() {
|
||||
input.reconnect_pending = true;
|
||||
}
|
||||
@@ -591,9 +606,8 @@ impl App {
|
||||
self.refresh_pending_thread_approvals().await;
|
||||
// Discover tasks whose notifications were missed, without clearing retained rows.
|
||||
// A hidden overview performs this discovery when it is next opened.
|
||||
self.agents_overview
|
||||
.initialized
|
||||
.remove(&app_server.backend_id());
|
||||
self.reset_agents_overview_discovery(app_server.backend_id());
|
||||
self.backend_registry.connect(app_server);
|
||||
if self.reconnect.presentation == ReconnectPresentation::Overview {
|
||||
let threads = self
|
||||
.agents_overview
|
||||
@@ -604,7 +618,6 @@ impl App {
|
||||
.collect();
|
||||
let view = self.agents_overview_view(threads, selected);
|
||||
self.chat_widget.show_bottom_pane_view(Box::new(view));
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
// The Overview survived request cleanup, but terminal typeahead may have survived too.
|
||||
if self.startup_protected_input_boundary {
|
||||
self.render_startup_frame(tui, app_event_rx)?;
|
||||
@@ -622,6 +635,9 @@ impl App {
|
||||
server.reconnect(app_server.request_handle(), self.app_event_tx.clone());
|
||||
}
|
||||
self.reconnect.offline = false;
|
||||
if self.reconnect.presentation == ReconnectPresentation::Overview {
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
}
|
||||
self.chat_widget.update_account_state(
|
||||
bootstrap.status_account_display,
|
||||
bootstrap.plan_type,
|
||||
|
||||
@@ -1141,10 +1141,14 @@ See the Codex keymap documentation for supported actions and examples."
|
||||
/*server_version*/ None,
|
||||
);
|
||||
}
|
||||
app.backend_registry.connect(&app_server);
|
||||
if let Some(thread_id) = app.current_displayed_thread_id() {
|
||||
app.backend_registry
|
||||
.observe(app_server.backend_id(), thread_id);
|
||||
}
|
||||
for session in &other_backends {
|
||||
app.backend_registry.connect(session);
|
||||
}
|
||||
if start_in_agents_overview {
|
||||
app.open_agents_overview(&app_server);
|
||||
} else {
|
||||
@@ -1627,6 +1631,10 @@ See the Codex keymap documentation for supported actions and examples."
|
||||
backends.defer_side_startup(event);
|
||||
}
|
||||
Some(event) if owner != displayed_owner || !app.reconnect.offline => {
|
||||
if matches!(&event.event, codex_app_server_client::AppServerEvent::Disconnected { .. }) {
|
||||
app.backend_registry.disconnect(owner);
|
||||
app.cancel_agents_overview_refresh(owner);
|
||||
}
|
||||
if let Some(slot) = backends.slot(owner) {
|
||||
let (session, parked_inputs) = backends.session_and_parked_inputs(slot);
|
||||
app.handle_polled_backend_event(session, displayed_owner, parked_inputs, event).await;
|
||||
@@ -1634,8 +1642,9 @@ See the Codex keymap documentation for supported actions and examples."
|
||||
}
|
||||
Some(_) => {}
|
||||
None => {
|
||||
app.agents_overview
|
||||
.invalidate_discovery(owner, owner == displayed_owner);
|
||||
app.backend_registry.disconnect(owner);
|
||||
app.cancel_agents_overview_refresh(owner);
|
||||
app.reset_agents_overview_discovery(owner);
|
||||
if owner == displayed_owner {
|
||||
if app.reconnect.offline && app.pending_startup_thread_start {
|
||||
reconnect = None;
|
||||
|
||||
@@ -31,7 +31,7 @@ async fn background_archive_and_delete_remove_only_owned_rows() -> Result<()> {
|
||||
.threads
|
||||
.insert(collision, Some(collision_row.clone()));
|
||||
|
||||
for deleted in [false, true] {
|
||||
for (index, deleted) in [false, true].into_iter().enumerate() {
|
||||
let id = ThreadId::new();
|
||||
assert!(app.backend_registry.observe(owner, id));
|
||||
let row = overview_thread(
|
||||
@@ -66,8 +66,9 @@ async fn background_archive_and_delete_remove_only_owned_rows() -> Result<()> {
|
||||
}
|
||||
assert!(!app.agents_overview.threads.contains_key(&id));
|
||||
assert!(app.agents_overview.threads.contains_key(&collision));
|
||||
assert!(app.agents_overview.refresh_invalidated);
|
||||
assert_eq!(app.agents_overview.refill_count, 0);
|
||||
assert!(app.agents_overview.active_refresh.is_none());
|
||||
assert_eq!(app.agents_overview.refill_count(displayed), 0);
|
||||
assert_eq!(app.agents_overview.refill_count(owner), index + 1);
|
||||
app.apply_agents_overview_thread_refresh(
|
||||
&server,
|
||||
request_id,
|
||||
@@ -102,8 +103,16 @@ async fn background_archive_and_delete_remove_only_owned_rows() -> Result<()> {
|
||||
assert!(!app.agents_overview.removed_threads.contains(&id));
|
||||
}
|
||||
}
|
||||
app.backend_registry.connect(&server);
|
||||
app.agents_overview
|
||||
.discovery
|
||||
.insert(owner, Default::default());
|
||||
app.show_more_agents_overview(&server);
|
||||
assert!(app.agents_overview.refresh_show_more);
|
||||
assert_eq!(
|
||||
app.agents_overview.active_refresh.map(|(_, id)| id),
|
||||
Some(owner)
|
||||
);
|
||||
assert!(!app.agents_overview.refresh_show_more);
|
||||
if let Some(task) = app.agents_overview.refresh_task.take() {
|
||||
task.abort();
|
||||
}
|
||||
@@ -201,7 +210,7 @@ async fn foreign_backend_events_leave_thread_cache_and_connection_untouched() ->
|
||||
assert!(!app.agents_overview.discovery.contains_key(&owner));
|
||||
assert!(!app.agents_overview.initialized.contains(&owner));
|
||||
assert!(app.agents_overview.initialized.contains(&foreign));
|
||||
assert!(app.agents_overview.refresh_invalidated);
|
||||
assert_eq!(app.agents_overview.active_refresh, None);
|
||||
}
|
||||
}
|
||||
assert!(!app.reconnect.offline);
|
||||
|
||||
@@ -159,7 +159,6 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv
|
||||
let stale_request = Uuid::new_v4();
|
||||
let refresh_owner = crate::backend_id::BackendId::new();
|
||||
app.agents_overview.active_refresh = Some((stale_request, refresh_owner));
|
||||
app.agents_overview.refresh_pending = true;
|
||||
let refresh = tokio::spawn(std::future::pending::<()>());
|
||||
app.agents_overview.refresh_task = Some(refresh.abort_handle());
|
||||
let directory = tempfile::tempdir()?;
|
||||
@@ -255,9 +254,23 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv
|
||||
crate::connect_remote_app_server(endpoint).await?,
|
||||
ThreadParamsMode::Embedded,
|
||||
);
|
||||
app.app_server_backend_id = Some(session.backend_id());
|
||||
app.backend_registry.connect(&session);
|
||||
let parked = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||||
let parked_owner = parked.backend_id();
|
||||
app.backend_registry.connect(&parked);
|
||||
app.backend_registry.observe(session.backend_id(), added);
|
||||
|
||||
app.agents_overview.pending_refresh_backends = [session.backend_id()].into();
|
||||
if overview_initialized {
|
||||
app.agents_overview.initialized.insert(session.backend_id());
|
||||
}
|
||||
if let Some(thread_id) = previous_thread {
|
||||
assert!(
|
||||
app.backend_registry
|
||||
.observe(session.backend_id(), thread_id)
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
session
|
||||
.thread_loaded_list(ThreadLoadedListParams {
|
||||
@@ -279,15 +292,16 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv
|
||||
app.handle_backend_event(&session, disconnected).await;
|
||||
assert_eq!(app.agents_overview.pending_usage, None);
|
||||
assert!(app.reconnect.offline);
|
||||
assert!(
|
||||
app.backend_registry
|
||||
.request_handle(session.backend_id())
|
||||
.is_none()
|
||||
);
|
||||
assert!(app.backend_registry.request_handle(parked_owner).is_some());
|
||||
assert!(app.agents_overview.last_messages.is_empty());
|
||||
assert!(refresh.await.unwrap_err().is_cancelled());
|
||||
assert_eq!(
|
||||
(
|
||||
app.agents_overview.active_refresh.map(|(id, _)| id),
|
||||
app.agents_overview.refresh_pending
|
||||
),
|
||||
(None, false)
|
||||
);
|
||||
assert_eq!(app.agents_overview.active_refresh, None);
|
||||
assert!(app.agents_overview.pending_refresh_backends.is_empty());
|
||||
app.apply_agents_overview_thread_refresh(
|
||||
&session,
|
||||
stale_request,
|
||||
@@ -384,6 +398,13 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv
|
||||
Ok::<_, color_eyre::Report>(())
|
||||
})
|
||||
.await??;
|
||||
assert!(
|
||||
app.backend_registry
|
||||
.request_handle(session.backend_id())
|
||||
.is_some()
|
||||
);
|
||||
assert!(app.backend_registry.request_handle(parked_owner).is_some());
|
||||
parked.shutdown().await?;
|
||||
assert!(app.agents_overview.visible_thread_ids.contains(&vanished));
|
||||
|
||||
// Missing metadata alone does not evict a retained row; an archive notification does.
|
||||
|
||||
@@ -454,6 +454,7 @@ async fn replacement_uses_server_defaults_and_preserves_explicit_launch_settings
|
||||
socket_path: client_home.path().join("daemon.sock").abs(),
|
||||
},
|
||||
};
|
||||
app.backend_registry.connect(&server);
|
||||
app.open_agents_overview(&server);
|
||||
}
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
@@ -1211,6 +1212,8 @@ async fn check_retained_draft_handoff(
|
||||
let retained = app.chat_widget.capture_thread_input_state().unwrap();
|
||||
app.chat_widget
|
||||
.restore_user_message_to_composer("draft for the displayed task".into());
|
||||
app.backend_registry.connect(&source);
|
||||
app.backend_registry.connect(&destination);
|
||||
let mut backends = BackendSessions::from_initial(source, vec![destination]);
|
||||
let destination_slot = backends
|
||||
.slot(destination_id)
|
||||
@@ -1262,7 +1265,7 @@ async fn check_retained_draft_handoff(
|
||||
}
|
||||
|
||||
app.agents_overview.initialized.insert(outgoing);
|
||||
app.agents_overview.show_more_requested = true;
|
||||
app.agents_overview.show_more_backends.insert(outgoing);
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
let pages_before = recorded_params(&requests, "thread/turns/list").len();
|
||||
let reads_before = recorded_params(&requests, "thread/read").len();
|
||||
@@ -1284,9 +1287,22 @@ async fn check_retained_draft_handoff(
|
||||
recorded_params(&requests, "thread/turns/list"),
|
||||
recorded_params(&requests, "thread/resume"),
|
||||
);
|
||||
assert_eq!(
|
||||
app.backend_registry.request_handle(outgoing).is_some(),
|
||||
history_capabilities != HistoryCapabilities::LegacyOnly,
|
||||
);
|
||||
assert!(
|
||||
app.backend_registry
|
||||
.request_handle(destination_id)
|
||||
.is_some()
|
||||
);
|
||||
assert!(app.agents_overview.initialized.contains(&outgoing));
|
||||
assert!(!app.agents_overview.initialized.contains(&destination_id));
|
||||
assert!(!app.agents_overview.show_more_requested);
|
||||
assert!(
|
||||
!app.agents_overview
|
||||
.show_more_backends
|
||||
.contains(&destination_id)
|
||||
);
|
||||
assert_eq!(app.chat_widget.thread_id(), Some(thread_id));
|
||||
if saved_history || parked_policy.is_some() {
|
||||
assert_eq!(
|
||||
|
||||
@@ -4534,7 +4534,7 @@ async fn agents_overview_seeds_loaded_threads_when_recent_listing_is_unavailable
|
||||
),
|
||||
(
|
||||
HistoryCapabilities::ThreadListFails,
|
||||
vec!["recency_at", "recency_at"],
|
||||
vec!["recency_at", "recency_at", "recency_at"],
|
||||
),
|
||||
] {
|
||||
let (mut app, _codex_home) = make_history_test_app().await?;
|
||||
@@ -4576,14 +4576,18 @@ async fn agents_overview_seeds_loaded_threads_when_recent_listing_is_unavailable
|
||||
.collect::<Vec<_>>(),
|
||||
vec![started.session.thread_id]
|
||||
);
|
||||
assert!(
|
||||
let initial_list_failed =
|
||||
attempt == 0 && capabilities == HistoryCapabilities::ThreadListFails;
|
||||
assert_eq!(
|
||||
app.agents_overview
|
||||
.initialized
|
||||
.contains(&app_server.backend_id())
|
||||
.contains(&app_server.backend_id()),
|
||||
!initial_list_failed
|
||||
);
|
||||
assert_eq!(
|
||||
app.agents_overview.has_more(app_server.backend_id()),
|
||||
capabilities == HistoryCapabilities::ThreadListFails
|
||||
app.agents_overview
|
||||
.has_more_for(&app.backend_registry, app_server.backend_id()),
|
||||
initial_list_failed
|
||||
);
|
||||
if attempt == 0 {
|
||||
app.handle_app_server_event(
|
||||
|
||||
@@ -51,6 +51,7 @@ use uuid::Uuid;
|
||||
|
||||
use crate::app_command::AppCommand;
|
||||
use crate::app_server_session::AppServerStartedThread;
|
||||
use crate::backend_id::BackendId;
|
||||
use crate::bottom_pane::ApprovalRequest;
|
||||
use crate::bottom_pane::StatusLineItem;
|
||||
use crate::bottom_pane::TerminalTitleItem;
|
||||
@@ -426,6 +427,7 @@ pub(crate) enum AppEvent {
|
||||
},
|
||||
/// Finish moving a task into or out of the shared pinned section.
|
||||
AgentsOverviewPinToggled {
|
||||
backend_id: BackendId,
|
||||
request_id: Uuid,
|
||||
thread_id: ThreadId,
|
||||
pinned: bool,
|
||||
|
||||
Reference in New Issue
Block a user