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
@@ -21,6 +21,8 @@ use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::MutexGuard;
|
||||
use std::sync::PoisonError;
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::atomic::Ordering;
|
||||
use tokio::sync::mpsc;
|
||||
use tokio::sync::oneshot;
|
||||
use tokio::time::Instant;
|
||||
@@ -121,6 +123,7 @@ pub(super) enum IdleReconnect {
|
||||
#[derive(Clone)]
|
||||
pub struct CloudRequestHandle {
|
||||
pub(super) reconnect: tokio::sync::watch::Sender<IdleReconnect>,
|
||||
pub(super) attached: Arc<AtomicBool>,
|
||||
commands: mpsc::Sender<CloudCommand>,
|
||||
native: Option<Arc<codex_cloud_client::Client>>,
|
||||
title_client: Option<Arc<CloudTitleClient>>,
|
||||
@@ -209,6 +212,7 @@ impl CloudClient {
|
||||
handle: CloudRequestHandle {
|
||||
commands,
|
||||
reconnect: Default::default(),
|
||||
attached: Default::default(),
|
||||
native: native.map(Arc::new),
|
||||
title_client: title_client.map(Arc::new),
|
||||
},
|
||||
@@ -281,6 +285,11 @@ impl CloudClient {
|
||||
}
|
||||
|
||||
impl CloudRequestHandle {
|
||||
/// Whether the worker has an installed reply stream that can deliver inventory updates.
|
||||
pub fn has_attachment(&self) -> bool {
|
||||
self.attached.load(Ordering::Relaxed) && !self.commands.is_closed()
|
||||
}
|
||||
|
||||
/// Generate metadata with Cloud's own account, outside its conversation command queue.
|
||||
pub async fn generate_thread_title(
|
||||
&self,
|
||||
@@ -462,6 +471,7 @@ impl CloudRequestHandle {
|
||||
Self {
|
||||
commands,
|
||||
reconnect: self.reconnect.clone(),
|
||||
attached: self.attached.clone(),
|
||||
native: None,
|
||||
title_client: None,
|
||||
},
|
||||
|
||||
@@ -837,8 +837,12 @@ async fn prepared_resume_keeps_the_previous_stream_until_handoff() -> Result<()>
|
||||
if outcome == "burst" {
|
||||
// One partial-history warning plus the entire live burst, including its unread tail.
|
||||
for _ in 0..PREPARED_EVENT_LIMIT + 2 {
|
||||
let mut event = client.next_event().await;
|
||||
while matches!(event, Some(AppServerEvent::CloudInventoryChanged(Some(_)))) {
|
||||
event = client.next_event().await;
|
||||
}
|
||||
assert!(
|
||||
matches!(client.next_event().await, Some(AppServerEvent::ServerNotification(notification))
|
||||
matches!(event, Some(AppServerEvent::ServerNotification(notification))
|
||||
if matches!(*notification, protocol::ServerNotification::Warning(_)))
|
||||
);
|
||||
}
|
||||
@@ -982,12 +986,20 @@ async fn accepted_idle_reconnect_reports_changed_login() -> Result<()> {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn attachment_status_follows_its_server_notifications() -> Result<()> {
|
||||
async fn attachment_tracks_its_status_and_reports_account_inventory_changes() -> Result<()> {
|
||||
let (output, mut events) = mpsc::unbounded_channel();
|
||||
let mut replies = Replies::default();
|
||||
let notifications: [&[u8]; 3] = [
|
||||
let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1);
|
||||
let handle = client.request_handle();
|
||||
let mut replies = Replies {
|
||||
attached: handle.attached.clone(),
|
||||
..Default::default()
|
||||
};
|
||||
let notifications: [&[u8]; 6] = [
|
||||
b"\x1a\x0d\x12\x0b\x0a\x06\x22\x04\x0a\x02\x08\x01\x12\x01t", // t is waiting
|
||||
b"\xaa\x01\x0c\x12\x0a\x0a\x01x\x12\x05\x22\x01u\x40\x04", // x starts a turn
|
||||
b"\x1a\x09\x12\x07\x0a\x02\x12\x00\x12\x01x", // x is idle
|
||||
b"\x22\x05\x12\x03\x0a\x01x", // x is archived
|
||||
b"\x32\x05\x12\x03\x0a\x01x", // x is unarchived
|
||||
b"\x1a\x09\x12\x07\x0a\x02\x12\x00\x12\x01t", // t is idle
|
||||
];
|
||||
let stream = stream::iter(
|
||||
@@ -1007,13 +1019,27 @@ async fn attachment_status_follows_its_server_notifications() -> Result<()> {
|
||||
let waiting = cloud::ThreadStatus::Active {
|
||||
active_flags: vec![cloud::ThreadActiveFlag::WaitingOnApproval],
|
||||
};
|
||||
assert_eq!(replies.thread_status("t"), Some(&waiting));
|
||||
replies.forward_next(&output).await;
|
||||
assert_eq!(replies.thread_status("t"), Some(&waiting));
|
||||
let waiting = serde_json::json!(waiting);
|
||||
let status_change = |status: &Value| serde_json::json!({"method": "thread/status/changed", "params": {"threadId": "t", "status": status}});
|
||||
for expected in [
|
||||
status_change(&waiting),
|
||||
Value::Null,
|
||||
Value::Null,
|
||||
serde_json::json!({"method": "thread/archived", "params": {"threadId": "x"}}),
|
||||
serde_json::json!({"method": "thread/unarchived", "params": {"threadId": "x"}}),
|
||||
status_change(&serde_json::json!(cloud::ThreadStatus::Idle)),
|
||||
] {
|
||||
let AppServerEvent::CloudInventoryChanged(lifecycle) = events.try_recv()? else {
|
||||
panic!("expected inventory change");
|
||||
};
|
||||
assert_eq!(serde_json::to_value(lifecycle)?, expected);
|
||||
let status = expected.pointer("/params/status").unwrap_or(&waiting);
|
||||
assert_eq!(&serde_json::to_value(replies.thread_status("t"))?, status);
|
||||
assert!(handle.has_attachment());
|
||||
replies.forward_next(&output).await;
|
||||
}
|
||||
|
||||
replies.forward_next(&output).await;
|
||||
assert_eq!(replies.thread_status("t"), Some(&cloud::ThreadStatus::Idle));
|
||||
replies.forward_next(&output).await;
|
||||
assert!(!handle.has_attachment());
|
||||
assert_eq!(replies.thread_status("t"), Some(&cloud::ThreadStatus::Idle));
|
||||
let AppServerEvent::ThreadStreamDisconnected(error) = events.try_recv()? else {
|
||||
panic!("expected a Cloud stream loss");
|
||||
@@ -1030,5 +1056,8 @@ async fn attachment_status_follows_its_server_notifications() -> Result<()> {
|
||||
.replace("t", async { Ok(stream::pending().boxed()) }, &output)
|
||||
.await?;
|
||||
assert_eq!(replies.thread_status("t"), None);
|
||||
assert!(handle.has_attachment());
|
||||
replies.detach("t");
|
||||
assert!(!handle.has_attachment());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -25,6 +25,8 @@ use futures::StreamExt;
|
||||
use futures::stream::BoxStream;
|
||||
use serde_json::Value;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::atomic::Ordering;
|
||||
use tokio::sync::mpsc;
|
||||
use tokio::sync::oneshot;
|
||||
|
||||
@@ -70,6 +72,7 @@ struct Attachment {
|
||||
struct Replies {
|
||||
idle: Option<idle::Recovery>,
|
||||
active: Option<Attachment>,
|
||||
attached: Arc<AtomicBool>,
|
||||
generation: u64,
|
||||
stream_losses: CloudStreamLosses,
|
||||
// Keep the last observed status through EOF until this conversation is unloaded.
|
||||
@@ -77,6 +80,12 @@ struct Replies {
|
||||
}
|
||||
|
||||
impl Replies {
|
||||
fn set_active(&mut self, active: Option<Attachment>) {
|
||||
self.active = active;
|
||||
self.attached
|
||||
.store(self.active.is_some(), Ordering::Relaxed);
|
||||
}
|
||||
|
||||
async fn next_event(&mut self, output: &mpsc::UnboundedSender<AppServerEvent>) {
|
||||
if let Some(recovery) = &mut self.idle
|
||||
&& let Some((root, _, open)) = &mut recovery.held
|
||||
@@ -158,7 +167,7 @@ impl Replies {
|
||||
ended => {
|
||||
let id = active.thread_id.clone();
|
||||
let error = ended.and_then(Result::err);
|
||||
self.active = None;
|
||||
self.set_active(/*active*/ None);
|
||||
if let Some(recovery) = &mut self.idle {
|
||||
recovery
|
||||
.state
|
||||
@@ -259,10 +268,10 @@ impl Replies {
|
||||
output: &mpsc::UnboundedSender<AppServerEvent>,
|
||||
) {
|
||||
self.generation = self.generation.wrapping_add(1);
|
||||
self.active = Some(Attachment {
|
||||
self.set_active(Some(Attachment {
|
||||
thread_id: id.to_owned(),
|
||||
stream,
|
||||
});
|
||||
}));
|
||||
if let Some(event) = first_event {
|
||||
forward(
|
||||
id,
|
||||
@@ -303,7 +312,7 @@ impl Replies {
|
||||
.as_ref()
|
||||
.is_some_and(|active| active.thread_id == id)
|
||||
{
|
||||
self.active = None;
|
||||
self.set_active(/*active*/ None);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -350,12 +359,10 @@ fn start_worker(
|
||||
loaded: None,
|
||||
warned_partial_history: None,
|
||||
};
|
||||
let handle = app_client.request_handle();
|
||||
let mut replies = Replies {
|
||||
idle: Some(idle::Recovery::new(
|
||||
app_client.request_handle().reconnect,
|
||||
client,
|
||||
login,
|
||||
)),
|
||||
attached: handle.attached,
|
||||
idle: Some(idle::Recovery::new(handle.reconnect, client, login)),
|
||||
stream_losses: app_client.stream_losses.clone(),
|
||||
..Default::default()
|
||||
};
|
||||
@@ -917,6 +924,15 @@ fn forward(
|
||||
recovery.observe_busy();
|
||||
}
|
||||
}
|
||||
if let Ok(status) = serde_json::from_value(serde_json::json!(&status)) {
|
||||
let change = protocol::ThreadStatusChangedNotification {
|
||||
thread_id: id.to_owned(),
|
||||
status,
|
||||
};
|
||||
let _ = output.send(AppServerEvent::CloudInventoryChanged(Some(Box::new(
|
||||
protocol::ServerNotification::ThreadStatusChanged(change),
|
||||
))));
|
||||
}
|
||||
*latest_status = Some((id.to_owned(), status));
|
||||
return;
|
||||
}
|
||||
@@ -944,7 +960,24 @@ fn forward(
|
||||
thread_id: Some(id.to_owned()),
|
||||
message: "This cloud turn requested an unsupported interaction. Open it in another client to continue.".into(),
|
||||
}),
|
||||
cloud::Event::Notification(_) => return,
|
||||
event @ cloud::Event::Notification(_) => {
|
||||
let lifecycle = match event.inventory_change() {
|
||||
Some(cloud::InventoryChange::Archived(thread_id)) => Some(
|
||||
protocol::ServerNotification::ThreadArchived(
|
||||
protocol::ThreadArchivedNotification { thread_id },
|
||||
),
|
||||
),
|
||||
Some(cloud::InventoryChange::Unarchived(thread_id)) => Some(
|
||||
protocol::ServerNotification::ThreadUnarchived(
|
||||
protocol::ThreadUnarchivedNotification { thread_id },
|
||||
),
|
||||
),
|
||||
Some(cloud::InventoryChange::Refresh) => None,
|
||||
None => return,
|
||||
};
|
||||
let _ = output.send(AppServerEvent::CloudInventoryChanged(lifecycle.map(Box::new)));
|
||||
return;
|
||||
}
|
||||
};
|
||||
send_notification(output, notification);
|
||||
}
|
||||
|
||||
@@ -69,6 +69,8 @@ pub enum AppServerEvent {
|
||||
},
|
||||
ServerNotification(Box<ServerNotification>),
|
||||
ServerRequest(Box<ServerRequest>),
|
||||
/// The signed-in Cloud account may have changed its discoverable thread inventory.
|
||||
CloudInventoryChanged(Option<Box<ServerNotification>>),
|
||||
/// A native Cloud reply stream ended. The underlying thread can still be running.
|
||||
ThreadStreamDisconnected(Box<codex_app_server_protocol::ErrorNotification>),
|
||||
/// The Cloud worker is listening again on the same conversation.
|
||||
|
||||
@@ -62,6 +62,7 @@ pub use items::ItemSummary;
|
||||
pub use prewarm::EnvironmentSelection;
|
||||
pub use prewarm::ProjectEnvironment;
|
||||
pub use transcript::FileUpdate;
|
||||
pub use transcript::InventoryChange;
|
||||
pub use transcript::ItemDelta;
|
||||
pub use transcript::PatchKind;
|
||||
pub use transcript::PatchUpdate;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Typed live transcript updates for the attached thread.
|
||||
//! Live transcript updates for the attached thread and account notifications on its stream.
|
||||
use crate::Error;
|
||||
use crate::Event;
|
||||
use crate::ThreadStatus;
|
||||
@@ -14,6 +14,13 @@ pub struct TranscriptEvent {
|
||||
pub update: TranscriptUpdate,
|
||||
}
|
||||
|
||||
/// Changes to the account's thread list reported over an attachment.
|
||||
pub enum InventoryChange {
|
||||
Archived(String),
|
||||
Unarchived(String),
|
||||
Refresh,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
pub enum TranscriptUpdate {
|
||||
ItemStarted(crate::ItemLifecycle),
|
||||
@@ -99,7 +106,11 @@ redacted_debug!(
|
||||
);
|
||||
|
||||
// Field numbers in the ASB Notification.value oneof.
|
||||
const THREAD_STARTED: u32 = 2;
|
||||
const THREAD_STATUS_CHANGED: u32 = 3;
|
||||
const THREAD_ARCHIVED: u32 = 4;
|
||||
const THREAD_UNARCHIVED: u32 = 6;
|
||||
const THREAD_NAME_UPDATED: u32 = 10;
|
||||
const TURN_STARTED: u32 = 21;
|
||||
const TURN_COMPLETED: u32 = 23;
|
||||
pub(super) const ITEM_STARTED: u32 = 27;
|
||||
@@ -124,6 +135,36 @@ pub(super) fn required<T>(value: Option<T>) -> Result<T, DecodeFailure> {
|
||||
value.ok_or(DecodeFailure::MissingField)
|
||||
}
|
||||
impl Event {
|
||||
/// Recognizes account updates carried alongside the attached thread's transcript.
|
||||
pub fn inventory_change(&self) -> Option<InventoryChange> {
|
||||
let Self::Notification(bytes) = self else {
|
||||
return None;
|
||||
};
|
||||
let (tag, values) = wire::notification(bytes).ok().flatten()?;
|
||||
match tag {
|
||||
THREAD_ARCHIVED | THREAD_UNARCHIVED => {
|
||||
let envelope =
|
||||
wire::merge_messages::<wire::Envelope<crate::wire::ThreadIdRequest>>(values)
|
||||
.ok()?;
|
||||
let id = envelope.params?.thread_id;
|
||||
if id.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(if tag == THREAD_ARCHIVED {
|
||||
InventoryChange::Archived(id)
|
||||
} else {
|
||||
InventoryChange::Unarchived(id)
|
||||
})
|
||||
}
|
||||
THREAD_STARTED
|
||||
| THREAD_STATUS_CHANGED
|
||||
| THREAD_NAME_UPDATED
|
||||
| TURN_STARTED
|
||||
| TURN_COMPLETED => Some(InventoryChange::Refresh),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a supported status update for this thread from an Attach notification.
|
||||
pub fn thread_status_for(&self, thread_id: &str) -> Option<ThreadStatus> {
|
||||
let Self::Notification(bytes) = self else {
|
||||
|
||||
@@ -1584,7 +1584,8 @@ async fn finish_turn(
|
||||
AppServerEvent::ThreadStreamDisconnected(error) => {
|
||||
anyhow::bail!("app-server stream disconnected: {}", error.error.message)
|
||||
}
|
||||
AppServerEvent::ThreadStreamReconnected(_) => {}
|
||||
AppServerEvent::CloudInventoryChanged(_)
|
||||
| AppServerEvent::ThreadStreamReconnected(_) => {}
|
||||
AppServerEvent::Lagged { skipped } => {
|
||||
let message = lagged_event_warning_message(skipped);
|
||||
warn!("{message}");
|
||||
|
||||
@@ -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