Preserve statusline provider selections across thread startup (#61986)

## What changed

- Pass the provider advertised by the picker into statusline resolution, preserving it when selection precedes the thread ID and avoiding a redundant global catalog lookup.
- Cancel failed readers and stop requesting provider-specific usage and workspace headline data until the provider is reselected.

## Testing

Extend reader tests to cover reselection before thread startup, resolution using only the thread catalog, and snapshot suppression after invalid provider content.

GitOrigin-RevId: 9531204cb6ef93c721dc7fafdc0a8fea8c20cb99
This commit is contained in:
Joe Savona
2026-11-17 07:27:10 +00:00
committed by copyberry
parent 47d9cde20e
commit 7fb4014d52
8 changed files with 133 additions and 31 deletions
+4 -1
View File
@@ -3,6 +3,7 @@
use super::App;
use crate::legacy_core::config::edit::ConfigEdit;
use crate::legacy_core::config::edit::ConfigEditsBuilder;
use crate::statusline_provider::StatuslineProvider;
use anyhow::Context;
use codex_config::types::BuiltinStatusLine;
use codex_config::types::StatusLineSelection;
@@ -15,6 +16,7 @@ impl App {
pub(super) async fn save_status_line_provider(
&mut self,
provider: StatusLineSelection,
provider_from_picker: Option<StatuslineProvider>,
) -> anyhow::Result<()> {
let value = match &provider {
StatusLineSelection::Builtin(BuiltinStatusLine::Default) => toml_edit::value("default"),
@@ -37,7 +39,8 @@ impl App {
self.local_settings.tui.status_line_provider = Some(Box::new(provider.clone()));
self.chat_widget.local_settings.tui.status_line_provider = Some(Box::new(provider));
self.chat_widget.reselect_statusline_provider();
self.chat_widget
.reselect_statusline_provider(provider_from_picker);
Ok(())
}
}
@@ -59,7 +59,8 @@ async fn remote_session_saves_to_the_active_local_profile() -> anyhow::Result<()
},
),
] {
app.save_status_line_provider(selection.clone()).await?;
app.save_status_line_provider(selection.clone(), /*provider_from_picker*/ None)
.await?;
let saved: toml::Table = toml::from_str(&std::fs::read_to_string(&profile)?)?;
assert_eq!(saved, expected);
assert_eq!(
@@ -105,7 +106,8 @@ async fn failed_write_preserves_the_file_and_the_live_selection() -> anyhow::Res
server: "work".into(),
tool: "usage".into(),
});
app.save_status_line_provider(active).await?;
app.save_status_line_provider(active, /*provider_from_picker*/ None)
.await?;
let before = (
app.local_settings.clone(),
app.chat_widget.local_settings.clone(),
@@ -113,7 +115,11 @@ async fn failed_write_preserves_the_file_and_the_live_selection() -> anyhow::Res
for contents in ["[malformed", "[[tui]]\ntheme = 'nord'\n"] {
std::fs::write(&path, contents)?;
let selection = StatusLineSelection::Builtin(BuiltinStatusLine::Default);
assert!(app.save_status_line_provider(selection).await.is_err());
assert!(
app.save_status_line_provider(selection, /*provider_from_picker*/ None)
.await
.is_err()
);
assert_eq!(std::fs::read_to_string(&path)?, contents);
assert_eq!(
(&app.local_settings, &app.chat_widget.local_settings),
@@ -148,7 +154,9 @@ async fn reloading_the_effective_feature_gate_and_reselecting_an_unchanged_prefe
.unwrap()
.clone();
std::fs::write(&path, configured.replace("tool='line'", "tool='elsewhere'")).unwrap();
app.save_status_line_provider(selected).await.unwrap();
app.save_status_line_provider(selected, /*provider_from_picker*/ None)
.await
.unwrap();
let stored: toml::Table = toml::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
assert_eq!(
stored["tui"]["status_line_provider"]["tool"].as_str(),
@@ -647,7 +647,7 @@ impl ChatWidget {
}
fn uses_workspace_headline(&self, status_line_items: &[StatusLineItem]) -> bool {
self.selected_statusline_provider().is_some()
self.provider_needs_snapshot()
|| status_line_items.contains(&StatusLineItem::WorkspaceHeadline)
}
@@ -9,6 +9,7 @@ use crate::backend_id::BackendId;
use crate::statusline_provider::ProviderId;
use crate::statusline_provider::ProviderSelection;
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;
@@ -35,7 +36,8 @@ use uuid::Uuid;
pub(super) struct ActiveStatuslineRead {
token: Uuid,
thread: Option<ThreadId>,
selection: StatusLineProviderId,
selection: ProviderId,
provider_from_picker: Option<StatuslineProvider>,
host_cwd: PathBuf,
startup: watch::Sender<()>,
cancel: CancellationToken,
@@ -89,8 +91,14 @@ impl ChatWidget {
}
}
pub(crate) fn reselect_statusline_provider(&mut self) {
pub(crate) fn reselect_statusline_provider(
&mut self,
provider_from_picker: Option<StatuslineProvider>,
) {
self.statusline_read = None;
if let Some(selection) = self.selected_statusline_provider() {
self.start_statusline_read(selection.into(), provider_from_picker);
}
self.refresh_status_line();
}
@@ -106,12 +114,30 @@ impl ChatWidget {
{
return true;
}
let selection = ProviderId::from(selection);
// An explicit choice may precede the first thread ID for this widget.
let provider_from_picker = self
.statusline_read
.as_mut()
.filter(|read| read.thread.is_none() && read.selection == selection)
.and_then(|read| read.provider_from_picker.take());
self.start_statusline_read(selection, provider_from_picker);
true
}
fn start_statusline_read(
&mut self,
selection: ProviderId,
provider_from_picker: Option<StatuslineProvider>,
) {
let token = Uuid::new_v4();
let (startup, ready) = watch::channel(());
let provider_from_picker = provider_from_picker.filter(|provider| provider.id == selection);
self.statusline_read = Some(ActiveStatuslineRead {
token,
thread: self.thread_id,
selection: selection.clone(),
selection,
provider_from_picker,
host_cwd: self.status_line_cwd().to_owned(),
startup,
cancel: CancellationToken::new(),
@@ -123,7 +149,17 @@ impl ChatWidget {
if self.thread_id.is_some() {
StatuslineReadEvent::send(&self.app_event_tx, token, ReadStep::Start(ready));
}
true
}
pub(super) fn provider_needs_snapshot(&self) -> bool {
if self
.statusline_read
.as_ref()
.is_some_and(|read| read.cancel.is_cancelled() && read.is_current(self))
{
return false;
}
self.selected_statusline_provider().is_some()
}
pub(crate) fn handle_statusline_read(
@@ -154,9 +190,12 @@ impl ChatWidget {
if backend != owner.backend_id() {
return;
}
let tree = result.unwrap_or_else(|name| UiTree(Some(UiNode::String(format!(
"Error loading statusline contents from {name}. Use /statusline to (re)select your provider and try again."
)))));
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."
))))
});
self.set_status_line(Some(tree.into()));
}
}
@@ -166,12 +205,15 @@ impl ChatWidget {
impl ActiveStatuslineRead {
fn is_current(&self, chat: &ChatWidget) -> bool {
self.thread == chat.thread_id
&& Some(&self.selection) == chat.selected_statusline_provider()
&& chat.selected_statusline_provider().is_some_and(|id| {
self.selection.server.as_str() == id.server
&& self.selection.tool.as_str() == id.tool
})
&& self.host_cwd == chat.status_line_cwd()
}
pub(super) fn server_ready(&self, server: &str) {
if self.selection.server == server {
if self.selection.server.as_str() == server {
self.startup.send_replace(());
}
}
@@ -183,11 +225,12 @@ impl ActiveStatuslineRead {
mut ready: watch::Receiver<()>,
) {
let Some(thread) = self.thread else { return };
let id = ProviderId {
server: self.selection.server.as_str().into(),
tool: self.selection.tool.as_str().into(),
};
let mut name = self.selection.tool.clone();
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();
@@ -204,7 +247,10 @@ impl ActiveStatuslineRead {
&client,
thread,
&cwd,
ProviderSelection::Saved(&id),
provider_from_picker.as_ref().map_or(
ProviderSelection::Saved(&id),
ProviderSelection::Discovered,
),
)
.await
{
@@ -240,6 +240,10 @@ impl Reader {
}
async fn resolve(&mut self) {
self.resolve_on(&[None, self.chat.thread_id]).await;
}
async fn resolve_on(&mut self, scopes: &[Option<ThreadId>]) {
let (ClientRequest::ConfigRead { .. }, config) = self.request().await else {
panic!("expected the selected thread's config");
};
@@ -249,21 +253,23 @@ impl Reader {
json!({"config":layer, "layers":[{"name":{"type":"user"}, "config":layer}]}),
)))
.unwrap();
for thread in [None, self.chat.thread_id.map(|id| id.to_string())] {
for thread in scopes {
let (ClientRequest::McpServerStatusList { params, .. }, reply) = self.request().await
else {
panic!("expected a selected-server lookup");
};
assert_eq!(
(params.server_name.as_deref(), params.thread_id),
(Some("fixture"), thread)
(Some("fixture"), thread.map(|id| id.to_string()))
);
let name = &self.chat.selected_statusline_provider().unwrap().tool;
let tool = json!({"name":name,"title":"Calendar","inputSchema":{},"_meta":{
"openai/ui":{"entrypoints":[{"type":"statusline","resourceUri":URI}]}
}});
reply.send(Ok(Ok(json!({"data":[{"name":"fixture","httpOrigin":null,"runtimeStatus":"connected",
"tools":{(name):tool},"resources":[],"resourceTemplates":[],"authStatus":"unsupported"}],"nextCursor":null})))).unwrap();
let row = crate::statusline_provider::test_support::row("fixture", vec![tool]);
reply
.send(Ok(Ok(json!({"data":[row],"nextCursor":null}))))
.unwrap();
}
}
@@ -356,6 +362,7 @@ async fn statusline_invalid_content_stops_polling_immediately() {
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.");
assert!(!reader.chat.provider_needs_snapshot());
reader.chat.refresh_status_line();
advance(/*millis*/ 60_000).await;
reader.assert_idle();
@@ -549,9 +556,18 @@ async fn statusline_explicit_reselection_restarts_a_failed_reader() {
.contains("Error loading statusline contents from Calendar")
);
reader.chat.reselect_statusline_provider();
// An explicit choice can arrive while the displayed thread is starting.
let thread = reader.chat.thread_id.take();
let provider = crate::statusline_provider::test_support::advertised(
"fixture",
"line",
"ui://global/footer",
);
reader.chat.reselect_statusline_provider(Some(provider));
reader.chat.thread_id = thread;
reader.chat.refresh_status_line();
reader.dispatch().await;
reader.resolve().await;
reader.resolve_on(&[reader.chat.thread_id]).await;
respond(reader.read(URI).await, r#""restored""#);
reader.dispatch().await;
assert_eq!(footer(&reader.chat).as_deref(), Some("restored"));
+1 -1
View File
@@ -402,7 +402,7 @@ impl ChatWidget {
}
fn selected_thread_usage(&self) -> SelectedThreadUsage {
if self.selected_statusline_provider().is_some() {
if self.provider_needs_snapshot() {
return SelectedThreadUsage {
credits: self.plan_type != Some(PlanType::Ent26),
estimated_cost: true,
+16 -2
View File
@@ -4,7 +4,7 @@ mod descriptor;
pub(crate) mod discovery;
mod inventory;
#[cfg(test)]
mod test_support;
pub(crate) mod test_support;
use crate::config_update::read_effective_config_with_layers;
use codex_app_server_client::AppServerRequestHandle;
@@ -52,6 +52,12 @@ impl From<&str> for McpServerName {
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct McpToolName(String);
impl McpToolName {
pub(super) fn as_str(&self) -> &str {
&self.0
}
}
impl From<&str> for McpToolName {
fn from(name: &str) -> Self {
Self(name.to_owned())
@@ -65,10 +71,18 @@ pub(crate) struct ProviderId {
pub(crate) tool: McpToolName,
}
impl From<&codex_config::types::StatusLineProviderId> for ProviderId {
fn from(id: &codex_config::types::StatusLineProviderId) -> Self {
Self {
server: id.server.as_str().into(),
tool: id.tool.as_str().into(),
}
}
}
pub(crate) enum ProviderSelection<'a> {
Saved(&'a ProviderId),
/// A provider advertised during the current picker refresh.
#[cfg_attr(not(test), expect(dead_code, reason = "staged picker selection"))]
Discovered(&'a StatuslineProvider),
}
@@ -1,6 +1,8 @@
#![cfg(test)]
//! Drive statusline RPCs through the same request handle a remote TUI uses.
use super::ProviderId;
use super::StatuslineProvider;
use codex_app_server_client::AppServerClient;
use codex_app_server_client::AppServerRequestHandle;
use codex_app_server_client::CloudClient;
@@ -29,10 +31,23 @@ pub(super) async fn reply(commands: &mut Requests, method: &str, params: Value,
command.response.send(Ok(Ok(result))).unwrap();
}
pub(super) fn row(name: &str, tools: Vec<Value>) -> Value {
pub(crate) fn row(name: &str, tools: Vec<Value>) -> Value {
let tools = tools
.into_iter()
.map(|tool| (tool["name"].as_str().unwrap().to_owned(), tool))
.collect::<serde_json::Map<_, _>>();
json!({"name":name,"runtimeStatus":"connected","httpOrigin":null,"tools":tools,"authStatus":"unsupported","resources":[],"resourceTemplates":[]})
}
pub(crate) fn advertised(server: &str, tool: &str, uri: &str) -> StatuslineProvider {
StatuslineProvider {
id: ProviderId {
server: server.into(),
tool: tool.into(),
},
title: "Calendar".into(),
uri: uri.into(),
plugin_id: None,
plugin_label: None,
}
}