From a3fc418fb29d15fff9df779575aee3a5ca1ea73d Mon Sep 17 00:00:00 2001 From: Joe Savona Date: Tue, 17 Nov 2026 06:09:16 +0000 Subject: [PATCH] Classify status line provider failures and shorten error messages (#61990) ## What changed Replace the generic provider error with concise status line messages for unavailable providers, timed-out reads, and other failures. Each message includes `/statusline` to help users reselect a provider. Classify lookup, snapshot, transport, RPC, and resource validation failures, and log the failure category without carrying raw RPC errors or resource content. ## Testing Update tests to assert specific resource validation errors and the displayed messages for invalid content, RPC failures, read timeouts, and provider lookup timeouts. GitOrigin-RevId: 4ae4953cf2552c1c146d77463680655697d0d444 --- .../tui/src/chatwidget/statusline_reader.rs | 95 +++++++++---------- .../chatwidget/statusline_reader/resource.rs | 72 ++++++++++++++ .../src/chatwidget/statusline_reader_tests.rs | 76 +++++++-------- codex-rs/tui/src/statusline_provider.rs | 10 +- codex-rs/tui/src/statusline_provider_tests.rs | 5 +- .../tui/tests/suite/statusline_provider.rs | 4 +- 6 files changed, 166 insertions(+), 96 deletions(-) create mode 100644 codex-rs/tui/src/chatwidget/statusline_reader/resource.rs diff --git a/codex-rs/tui/src/chatwidget/statusline_reader.rs b/codex-rs/tui/src/chatwidget/statusline_reader.rs index e9cf0d00ac..2323e24a8f 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader.rs @@ -1,5 +1,10 @@ //! Poll the displayed thread’s statusline resource until a read fails or the reader is retired. +mod resource; + +use self::resource::Failure; +use self::resource::ReadIssue; +use self::resource::decode_tree; use super::ChatWidget; use super::statusline_state::StatuslineState; use crate::app_event::AppEvent; @@ -12,16 +17,11 @@ use crate::statusline_provider::ResolvedStatuslineProvider; use crate::statusline_provider::StatuslineProvider; use crate::ui_tree::UiNode; use crate::ui_tree::UiTree; -use codex_app_server_protocol::McpResourceContent; use codex_config::types::StatusLineProviderId; use codex_config::types::StatusLineSelection; use codex_features::Feature; use codex_protocol::ThreadId; use codex_utils_path_uri::LegacyAppPathString; -use color_eyre::eyre::Result; -use color_eyre::eyre::WrapErr; -use color_eyre::eyre::bail; -use color_eyre::eyre::eyre; use std::path::PathBuf; use std::time::Duration; use tokio::sync::oneshot; @@ -61,7 +61,7 @@ enum ReadStep { #[debug("Snapshot(..)")] Snapshot(BackendId, oneshot::Sender), #[debug("Finished(..)")] - Finished(BackendId, Result), + Finished(BackendId, Result), } impl StatuslineReadEvent { @@ -171,12 +171,13 @@ impl ChatWidget { event: StatuslineReadEvent, owner: &AppServerSession, ) { - let Some(footer) = self.statusline_read.as_ref() else { + let Some(footer) = self + .statusline_read + .as_ref() + .filter(|read| read.token == event.token) + else { return; }; - if event.token != footer.token { - return; - } if !footer.is_current(self) { self.refresh_status_line(); return; @@ -194,12 +195,19 @@ impl ChatWidget { if backend != owner.backend_id() { return; } - let tree = result.unwrap_or_else(|name| { - footer.cancel.cancel(); - UiTree(Some(UiNode::String(format!( - "Error loading statusline contents from {name}. Use /statusline to (re)select your provider and try again." - )))) - }); + let tree = match result { + Ok(tree) => tree, + Err(failure) => { + footer.cancel.cancel(); + tracing::warn!(?failure, "Status line provider stopped"); + let message = match failure { + Failure::Read(ReadIssue::TimedOut) => "Status line timed out", + Failure::Lookup => "Status line unavailable", + Failure::Snapshot | Failure::Read(_) => "Status line failed", + }; + UiTree(Some(UiNode::String(format!("{message} · /statusline")))) + } + }; self.set_status_line(Some(tree.into())); } } @@ -231,10 +239,6 @@ impl ActiveStatuslineRead { let Some(thread) = self.thread else { return }; let id = self.selection.clone(); let provider_from_picker = self.provider_from_picker.clone(); - let mut name = provider_from_picker.as_ref().map_or_else( - || id.tool.as_str().to_owned(), - |provider| provider.title.clone(), - ); let token = self.token; let events = events.clone(); let client = owner.request_handle(); @@ -242,9 +246,9 @@ impl ActiveStatuslineRead { let cwd = LegacyAppPathString::from_path(&self.host_cwd).to_inferred_path_uri(); let cancel = self.cancel.clone(); tokio::spawn(async move { - let result: Option> = cancel + let result: Option> = cancel .run_until_cancelled(async { - let cwd = cwd.ok_or_else(|| eyre!("invalid app-server working directory"))?; + let cwd = cwd.ok_or(Failure::Lookup)?; let provider = timeout(Duration::from_secs(/*secs*/ 5), async { loop { if let Ok(Some(provider)) = ResolvedStatuslineProvider::lookup( @@ -258,14 +262,14 @@ impl ActiveStatuslineRead { ) .await { - return Ok::<_, watch::error::RecvError>(provider); + return Ok::<_, Failure>(provider); } // A cold catalog may arrive before the selected MCP server finishes starting. - ready.changed().await?; + ready.changed().await.map_err(|_| Failure::Lookup)?; } }) - .await??; - name.clone_from(&provider.provider().title); + .await + .map_err(|_| Failure::Lookup)??; loop { let (reply, snapshot) = oneshot::channel(); StatuslineReadEvent::send( @@ -273,14 +277,16 @@ impl ActiveStatuslineRead { token, ReadStep::Snapshot(backend, reply), ); - let snapshot = serde_json::to_value(snapshot.await?)?; - let deadline = Instant::now() + Duration::from_secs(1); + let state = snapshot.await.map_err(|_| Failure::Snapshot)?; + let snapshot = + serde_json::to_value(state).map_err(|_| Failure::Snapshot)?; + let deadline = Instant::now() + Duration::from_secs(/*secs*/ 1); // A ready reply can win the final poll of timeout_at after the deadline. let response = match timeout_at(deadline, provider.read(snapshot)).await { - Ok(response) if Instant::now() < deadline => response?, - Ok(_) | Err(_) => { - bail!("resource read timed out"); + Ok(response) if Instant::now() < deadline => { + response.map_err(ReadIssue::from)? } + Ok(_) | Err(_) => return Err(ReadIssue::TimedOut.into()), }; let tree = decode_tree(&provider.provider().uri, &response.contents)?; StatuslineReadEvent::send( @@ -292,32 +298,17 @@ impl ActiveStatuslineRead { } }) .await; - if let Some(Err(_)) = result { - StatuslineReadEvent::send(&events, token, ReadStep::Finished(backend, Err(name))); + if let Some(Err(failure)) = result { + StatuslineReadEvent::send( + &events, + token, + ReadStep::Finished(backend, Err(failure)), + ); } }); } } -fn decode_tree(uri: &str, contents: &[McpResourceContent]) -> Result { - let [ - McpResourceContent::Text { - uri: returned_uri, - mime_type: Some(mime), - text, - .. - }, - ] = contents - else { - bail!("expected one text resource"); - }; - let media_type = mime.split(';').next().unwrap_or_default().trim(); - if uri != returned_uri || !media_type.eq_ignore_ascii_case("application/json") { - bail!("expected application/json at the advertised resource URI"); - } - text.parse().wrap_err("invalid UI tree") -} - #[cfg(test)] #[path = "statusline_reader_tests.rs"] mod tests; diff --git a/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs b/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs new file mode 100644 index 0000000000..ccd761e9fd --- /dev/null +++ b/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs @@ -0,0 +1,72 @@ +//! Classify provider failures without carrying raw RPC errors or resource content. + +use super::UiTree; +use codex_app_server_client::TypedRequestError; +use codex_app_server_protocol::McpResourceContent; + +#[derive(Debug, PartialEq, Eq, thiserror::Error)] +pub(super) enum ReadIssue { + #[error("timed out after 1 second")] + TimedOut, + #[error("failed in transport")] + Transport, + #[error("was rejected with code {0}")] + Rejected(i64), + #[error("returned an invalid app-server response")] + Response, + #[error("expected exactly one text resource")] + Envelope, + #[error("resource URI differs from the advertised URI")] + Uri, + #[error("expected application/json on the resource")] + Mime, + #[error("resource text is not a valid, bounded UI tree")] + Tree, +} + +impl From for ReadIssue { + fn from(error: TypedRequestError) -> Self { + match error { + TypedRequestError::Transport { .. } => Self::Transport, + TypedRequestError::Server { source, .. } => Self::Rejected(source.code), + TypedRequestError::Deserialize { .. } => Self::Response, + } + } +} + +#[derive(Debug, thiserror::Error)] +pub(super) enum Failure { + #[error("The selected provider could not be resolved for this thread.")] + Lookup, + #[error("The displayed thread could not supply its current status line state.")] + Snapshot, + #[error("Resource read: {0}.")] + Read(#[from] ReadIssue), +} + +pub(super) fn decode_tree(uri: &str, contents: &[McpResourceContent]) -> Result { + let [ + McpResourceContent::Text { + uri: returned_uri, + mime_type, + text, + .. + }, + ] = contents + else { + return Err(ReadIssue::Envelope); + }; + if uri != returned_uri { + return Err(ReadIssue::Uri); + } + let media_type = mime_type + .as_deref() + .unwrap_or_default() + .split(';') + .next() + .unwrap_or_default(); + if !media_type.trim().eq_ignore_ascii_case("application/json") { + return Err(ReadIssue::Mime); + } + text.parse().map_err(|_| ReadIssue::Tree) +} diff --git a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs index 84b0844240..fb0b44fe34 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs @@ -12,6 +12,7 @@ use codex_app_server_client::CloudCommand; use codex_app_server_client::CloudOperation; use codex_app_server_client::RequestResult; use codex_app_server_protocol::ClientRequest; +use codex_app_server_protocol::McpResourceContent; use codex_config::types::BuiltinStatusLine; use pretty_assertions::assert_eq; use ratatui::buffer::Buffer; @@ -31,20 +32,22 @@ fn statusline_resource_requires_one_matching_json_text_item() { decode_tree(uri, std::slice::from_ref(&item)).unwrap(), UiTree(None) ); - for contents in [ - vec![], - vec![item.clone(), item], - vec![content( - json!({"uri":"ui://wrong","mimeType":"application/json","text":"null"}), - )], - vec![content(json!({"uri":uri,"text":"null"}))], - vec![content( - json!({"uri":uri,"mimeType":"application/json","blob":"bnVsbA=="}), - )], - vec![text("text/plain", "null")], - vec![text("application/json", "{")], + let wrong_uri = + content(json!({"uri":"ui://wrong","mimeType":"application/json","text":"null"})); + let blob = content(json!({"uri":uri,"mimeType":"application/json","blob":"bnVsbA=="})); + for (contents, expected) in [ + (vec![], ReadIssue::Envelope), + (vec![item.clone(), item], ReadIssue::Envelope), + (vec![wrong_uri], ReadIssue::Uri), + ( + vec![content(json!({"uri":uri,"text":"null"}))], + ReadIssue::Mime, + ), + (vec![blob], ReadIssue::Envelope), + (vec![text("text/plain", "null")], ReadIssue::Mime), + (vec![text("application/json", "{")], ReadIssue::Tree), ] { - assert!(decode_tree(uri, &contents).is_err()); + assert_eq!(decode_tree(uri, &contents).unwrap_err(), expected); } } @@ -153,7 +156,7 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() chat.read_only_history = false; chat.refresh_status_line(); let [resumed] = read_events(&mut rx).try_into().unwrap(); - chat.handle_statusline_read(finish(token, None), &server); + chat.handle_statusline_read(finish(token, /*root*/ None), &server); assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); let token = resumed.token; chat.primary_environment_cwd = Some(crate::session_state::EnvironmentCwd { @@ -361,7 +364,7 @@ async fn statusline_invalid_content_stops_polling_immediately() { respond(invalid, "{"); reader.dispatch().await; assert_eq!(failed.elapsed(), Duration::ZERO); - insta::assert_snapshot!(footer(&reader.chat).unwrap(), @"Error loading statusline contents from Calendar. Use /statusline to (re)select your provider and try again."); + insta::assert_snapshot!(footer(&reader.chat).unwrap(), @"Status line failed · /statusline"); assert!(!reader.chat.provider_needs_snapshot()); reader.chat.refresh_status_line(); advance(/*millis*/ 60_000).await; @@ -377,14 +380,15 @@ async fn statusline_rpc_error_stops_polling_immediately() { assert_eq!(resolved.elapsed(), Duration::ZERO); let failed = Instant::now(); reply - .send(Err(std::io::Error::other("provider disconnected"))) + .send(Err(std::io::Error::other( + "PRIVATE provider error and account data", + ))) .unwrap(); reader.dispatch().await; assert_eq!(failed.elapsed(), Duration::ZERO); - assert!( - footer(&reader.chat) - .unwrap() - .contains("Error loading statusline contents from Calendar") + assert_eq!( + footer(&reader.chat).as_deref(), + Some("Status line failed · /statusline") ); advance(/*millis*/ 60_000).await; reader.assert_idle(); @@ -436,10 +440,9 @@ async fn statusline_deadline_wins_when_a_late_reply_is_already_queued() { assert!(futures::poll!(&mut advance).is_pending()); respond(reply, r#""too late""#); reader.dispatch().await; - assert!( - footer(&reader.chat) - .unwrap() - .contains("Error loading statusline contents from Calendar") + assert_eq!( + footer(&reader.chat).as_deref(), + Some("Status line timed out · /statusline") ); } @@ -454,12 +457,13 @@ async fn statusline_hung_read_stops_polling_after_one_second() { advance(/*millis*/ 1).await; reader.dispatch().await; assert_eq!(started.elapsed(), Duration::from_secs(1)); - assert!( - footer(&reader.chat) - .unwrap() - .contains("Error loading statusline contents from Calendar") + assert_eq!( + footer(&reader.chat).as_deref(), + Some("Status line timed out · /statusline") ); assert!(held.is_closed()); + reader.chat.local_settings.tui.status_line_provider = None; + reader.chat.refresh_status_line(); advance(/*millis*/ 60_000).await; reader.assert_idle(); } @@ -476,10 +480,9 @@ async fn statusline_startup_timeout_stops_before_the_first_read() { advance(/*millis*/ 1).await; reader.dispatch().await; assert_eq!(started.elapsed(), Duration::from_secs(5)); - assert!( - footer(&reader.chat) - .unwrap() - .contains("Error loading statusline contents from line") + assert_eq!( + footer(&reader.chat).as_deref(), + Some("Status line unavailable · /statusline") ); assert!(held.is_closed()); reader.chat.refresh_status_line(); @@ -530,7 +533,7 @@ async fn statusline_changing_provider_or_reconnecting_discards_the_previous_read reader.resolve().await; let next = reader.read(URI).await; held.closed().await; - for result in [Ok(UiTree(None)), Err("retired".into())] { + for result in [Ok(UiTree(None)), Err(Failure::Snapshot)] { let step = ReadStep::Finished(reader.owner.backend_id(), result); reader .chat @@ -550,10 +553,9 @@ async fn statusline_explicit_reselection_restarts_a_failed_reader() { reader.dispatch().await; reader.chat.refresh_status_line(); reader.assert_idle(); - assert!( - footer(&reader.chat) - .unwrap() - .contains("Error loading statusline contents from Calendar") + assert_eq!( + footer(&reader.chat).as_deref(), + Some("Status line timed out · /statusline") ); // An explicit choice can arrive while the displayed thread is starting. diff --git a/codex-rs/tui/src/statusline_provider.rs b/codex-rs/tui/src/statusline_provider.rs index fdaa8a51a1..db92d8b462 100644 --- a/codex-rs/tui/src/statusline_provider.rs +++ b/codex-rs/tui/src/statusline_provider.rs @@ -188,10 +188,12 @@ impl ResolvedStatuslineProvider { /// A thread/start override can also replace a configured command before lookup. Both /// registrations report the same name and no plugin ID. Same-owner plugin replacements /// are indistinguishable for the same reason. - pub(crate) async fn read(&self, snapshot: Value) -> Result { + pub(crate) async fn read( + &self, + snapshot: Value, + ) -> Result { let provider = &self.provider; - Ok(self - .client + self.client .request_typed(ClientRequest::McpResourceRead { request_id: RequestId::String(Uuid::new_v4().to_string()), params: McpResourceReadParams { @@ -208,7 +210,7 @@ impl ResolvedStatuslineProvider { )])), }, }) - .await?) + .await } } diff --git a/codex-rs/tui/src/statusline_provider_tests.rs b/codex-rs/tui/src/statusline_provider_tests.rs index bf5c72045f..add3add164 100644 --- a/codex-rs/tui/src/statusline_provider_tests.rs +++ b/codex-rs/tui/src/statusline_provider_tests.rs @@ -130,7 +130,10 @@ async fn picker_choice_reads_the_displayed_threads_uri_with_the_snapshot() -> Re .await? .unwrap(); assert_eq!(provider.provider().title, "Next event"); - provider.read(snapshot.clone()).await + provider + .read(snapshot.clone()) + .await + .map_err(color_eyre::Report::from) }; let (result, ()) = tokio::join!(read, host); result?; diff --git a/codex-rs/tui/tests/suite/statusline_provider.rs b/codex-rs/tui/tests/suite/statusline_provider.rs index 9dbc493028..f264fa8e5c 100644 --- a/codex-rs/tui/tests/suite/statusline_provider.rs +++ b/codex-rs/tui/tests/suite/statusline_provider.rs @@ -99,7 +99,7 @@ async fn statusline_reads_the_selected_stdio_resource_on_the_displayed_thread() } fs::write(&barrier, "")?; if mode == Setup::ProjectShadow { - terminal.wait_for_screen("Error loading statusline contents from sandbox_meta")?; + terminal.wait_for_screen("Status line unavailable · /statusline")?; assert!(!receipt.exists()); assert!(!shadow.exists()); } else { @@ -154,7 +154,7 @@ async fn statusline_reads_the_selected_stdio_resource_on_the_displayed_thread() toml::Value::String("replacement".into()); fs::write(&local_config, toml::to_string(&config)?)?; terminal.write_input(b"/new\r")?; - terminal.wait_for_screen("Error loading statusline contents from replacement")?; + terminal.wait_for_screen("Status line unavailable · /statusline")?; } assert_eq!(state["thread"]["workspace"], json!({"cwd": cwd})); }