mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
Poll MCP statusline providers with fresh state and bounded reads (#61981)
## Why MCP statusline resources were read only once, leaving the footer stale when thread state or the display mode changed. ## What changed - Read the selected provider again one second after each successful read, capturing fresh statusline state for every request. - Enforce a one-second resource read deadline and stop polling with an error footer on timeouts, RPC errors, or invalid content. - Cancel outstanding reads when the reader is retired, including thread switches and parking a voice session, and disable provider reads in voice-only mode. ## Testing Add paused-time tests for polling cadence, fresh state, empty content, failure handling, deadlines, and cancellation. Extend the stdio provider integration test to verify that switching out of raw mode updates the provider footer. GitOrigin-RevId: 159f17ad9291923e438117d919c875051c9d9426
This commit is contained in:
@@ -18,6 +18,7 @@ impl ChatWidget {
|
||||
|
||||
pub(crate) fn park_voice(&mut self) {
|
||||
self.app_event_tx.voice_only.store(true, Ordering::Relaxed);
|
||||
self.statusline_read = None;
|
||||
self.set_queue_autosend_suppressed(/*suppressed*/ true);
|
||||
self.stop_rate_limit_poller();
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Read one statusline resource for the displayed thread and keep its footer through native refreshes.
|
||||
//! Poll the displayed thread’s statusline resource until a read fails or the reader is retired.
|
||||
|
||||
use super::ChatWidget;
|
||||
use super::statusline_state::StatuslineState;
|
||||
@@ -25,6 +25,11 @@ use std::path::PathBuf;
|
||||
use std::time::Duration;
|
||||
use tokio::sync::oneshot;
|
||||
use tokio::sync::watch;
|
||||
use tokio::time::Instant;
|
||||
use tokio::time::sleep;
|
||||
use tokio::time::timeout;
|
||||
use tokio::time::timeout_at;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
use uuid::Uuid;
|
||||
|
||||
pub(super) struct ActiveStatuslineRead {
|
||||
@@ -33,6 +38,13 @@ pub(super) struct ActiveStatuslineRead {
|
||||
selection: StatusLineProviderId,
|
||||
host_cwd: PathBuf,
|
||||
startup: watch::Sender<()>,
|
||||
cancel: CancellationToken,
|
||||
}
|
||||
|
||||
impl Drop for ActiveStatuslineRead {
|
||||
fn drop(&mut self) {
|
||||
self.cancel.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -59,6 +71,10 @@ impl StatuslineReadEvent {
|
||||
impl ChatWidget {
|
||||
pub(super) fn selected_statusline_provider(&self) -> Option<&StatusLineProviderId> {
|
||||
if self.read_only_history
|
||||
|| self
|
||||
.app_event_tx
|
||||
.voice_only
|
||||
.load(std::sync::atomic::Ordering::Relaxed)
|
||||
|| !self
|
||||
.config
|
||||
.features
|
||||
@@ -92,6 +108,7 @@ impl ChatWidget {
|
||||
selection: selection.clone(),
|
||||
host_cwd: self.status_line_cwd().to_owned(),
|
||||
startup,
|
||||
cancel: CancellationToken::new(),
|
||||
});
|
||||
self.bottom_pane.set_status_line_enabled(/*enabled*/ true);
|
||||
self.set_status_line(Some(
|
||||
@@ -170,39 +187,58 @@ impl ActiveStatuslineRead {
|
||||
let client = owner.request_handle();
|
||||
let backend = owner.backend_id();
|
||||
let cwd = LegacyAppPathString::from_path(&self.host_cwd).to_inferred_path_uri();
|
||||
let cancel = self.cancel.clone();
|
||||
tokio::spawn(async move {
|
||||
let result: Result<UiTree> = async {
|
||||
let cwd = cwd.ok_or_else(|| eyre!("invalid app-server working directory"))?;
|
||||
let provider = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {
|
||||
loop {
|
||||
if let Ok(Some(provider)) = ResolvedStatuslineProvider::lookup(
|
||||
&client,
|
||||
thread,
|
||||
&cwd,
|
||||
ProviderSelection::Saved(&id),
|
||||
)
|
||||
.await
|
||||
{
|
||||
return Ok::<_, watch::error::RecvError>(provider);
|
||||
let result: Option<Result<()>> = cancel
|
||||
.run_until_cancelled(async {
|
||||
let cwd = cwd.ok_or_else(|| eyre!("invalid app-server working directory"))?;
|
||||
let provider = timeout(Duration::from_secs(/*secs*/ 5), async {
|
||||
loop {
|
||||
if let Ok(Some(provider)) = ResolvedStatuslineProvider::lookup(
|
||||
&client,
|
||||
thread,
|
||||
&cwd,
|
||||
ProviderSelection::Saved(&id),
|
||||
)
|
||||
.await
|
||||
{
|
||||
return Ok::<_, watch::error::RecvError>(provider);
|
||||
}
|
||||
// A cold catalog may arrive before the selected MCP server finishes starting.
|
||||
ready.changed().await?;
|
||||
}
|
||||
// A cold catalog may arrive before the selected MCP server finishes starting.
|
||||
ready.changed().await?;
|
||||
})
|
||||
.await??;
|
||||
name.clone_from(&provider.provider().title);
|
||||
loop {
|
||||
let (reply, snapshot) = oneshot::channel();
|
||||
StatuslineReadEvent::send(
|
||||
&events,
|
||||
token,
|
||||
ReadStep::Snapshot(backend, reply),
|
||||
);
|
||||
let snapshot = serde_json::to_value(snapshot.await?)?;
|
||||
let deadline = Instant::now() + Duration::from_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");
|
||||
}
|
||||
};
|
||||
let tree = decode_tree(&provider.provider().uri, &response.contents)?;
|
||||
StatuslineReadEvent::send(
|
||||
&events,
|
||||
token,
|
||||
ReadStep::Finished(backend, Ok(tree)),
|
||||
);
|
||||
sleep(Duration::from_secs(/*secs*/ 1)).await;
|
||||
}
|
||||
})
|
||||
.await??;
|
||||
name.clone_from(&provider.provider().title);
|
||||
// Lookup can outlive the displayed thread or its current usage measurements.
|
||||
let (reply, current) = oneshot::channel();
|
||||
StatuslineReadEvent::send(&events, token, ReadStep::Snapshot(backend, reply));
|
||||
let response = provider.read(serde_json::to_value(current.await?)?).await?;
|
||||
decode_tree(&provider.provider().uri, &response.contents)
|
||||
.await;
|
||||
if let Some(Err(_)) = result {
|
||||
StatuslineReadEvent::send(&events, token, ReadStep::Finished(backend, Err(name)));
|
||||
}
|
||||
.await;
|
||||
StatuslineReadEvent::send(
|
||||
&events,
|
||||
token,
|
||||
ReadStep::Finished(backend, result.map_err(|_| name)),
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +1,17 @@
|
||||
#![cfg(test)]
|
||||
//! Exercise the MCP response envelope and the displayed footer's one-shot lifecycle.
|
||||
//! Exercise the MCP response envelope and the displayed footer’s polling lifecycle.
|
||||
|
||||
use super::*;
|
||||
use crate::app_server_session::ThreadParamsMode;
|
||||
use crate::bottom_pane::StatusLineFocus;
|
||||
use crate::chatwidget::tests::make_chatwidget_manual_with_sender;
|
||||
use crate::chatwidget::tests::render_bottom_popup;
|
||||
use codex_app_server_client::AppServerClient;
|
||||
use codex_app_server_client::CloudClient;
|
||||
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_config::types::BuiltinStatusLine;
|
||||
use pretty_assertions::assert_eq;
|
||||
use ratatui::buffer::Buffer;
|
||||
@@ -12,6 +19,7 @@ use ratatui::buffer::Cell;
|
||||
use ratatui::layout::Rect;
|
||||
use serde_json::json;
|
||||
use tokio::sync::mpsc::UnboundedReceiver;
|
||||
use tokio::time::Instant;
|
||||
|
||||
#[test]
|
||||
fn statusline_resource_requires_one_matching_json_text_item() {
|
||||
@@ -175,3 +183,298 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result()
|
||||
);
|
||||
assert_eq!(footer(&chat).as_deref(), Some("Initializing…"));
|
||||
}
|
||||
|
||||
type Reply = oneshot::Sender<std::io::Result<RequestResult>>;
|
||||
const URI: &str = "ui://fixture/status";
|
||||
|
||||
struct Reader {
|
||||
chat: ChatWidget,
|
||||
owner: AppServerSession,
|
||||
events: UnboundedReceiver<AppEvent>,
|
||||
requests: tokio::sync::mpsc::Receiver<CloudCommand>,
|
||||
}
|
||||
|
||||
impl Reader {
|
||||
async fn new() -> Self {
|
||||
let (mut chat, _, events, _) = make_chatwidget_manual_with_sender().await;
|
||||
let (client, requests, _) = CloudClient::channel(/*capacity*/ 8);
|
||||
let owner = AppServerSession::new(
|
||||
BackendId::new(),
|
||||
AppServerClient::Cloud(client),
|
||||
ThreadParamsMode::Cloud,
|
||||
);
|
||||
chat.thread_id = Some(ThreadId::new());
|
||||
chat.set_feature_enabled(Feature::TuiExtensionsStatusLine, /*enabled*/ true);
|
||||
chat.local_settings.tui.status_line_provider =
|
||||
Some(Box::new(StatusLineSelection::Mcp(StatusLineProviderId {
|
||||
server: "fixture".into(),
|
||||
tool: "line".into(),
|
||||
})));
|
||||
chat.refresh_status_line();
|
||||
let mut reader = Self {
|
||||
chat,
|
||||
owner,
|
||||
events,
|
||||
requests,
|
||||
};
|
||||
reader.dispatch().await;
|
||||
reader
|
||||
}
|
||||
|
||||
async fn dispatch(&mut self) {
|
||||
while let Some(event) = self.events.recv().await {
|
||||
if let AppEvent::StatuslineRead(event) = event {
|
||||
self.chat.handle_statusline_read(event, &self.owner);
|
||||
return;
|
||||
}
|
||||
}
|
||||
panic!("reader event channel closed");
|
||||
}
|
||||
|
||||
async fn request(&mut self) -> (ClientRequest, Reply) {
|
||||
let command = self.requests.recv().await.unwrap();
|
||||
let CloudOperation::Request(request) = command.operation else {
|
||||
panic!("expected an app-server request");
|
||||
};
|
||||
(*request, command.response)
|
||||
}
|
||||
|
||||
async fn resolve(&mut self) {
|
||||
let (ClientRequest::ConfigRead { .. }, config) = self.request().await else {
|
||||
panic!("expected the selected thread's config");
|
||||
};
|
||||
let layer = json!({"mcp_servers":{"fixture":{"command":"fixture"}}});
|
||||
config
|
||||
.send(Ok(Ok(
|
||||
json!({"config":layer, "layers":[{"name":{"type":"user"}, "config":layer}]}),
|
||||
)))
|
||||
.unwrap();
|
||||
for thread in [None, self.chat.thread_id.map(|id| id.to_string())] {
|
||||
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)
|
||||
);
|
||||
let tool = json!({"name":"line","title":"Calendar","inputSchema":{},"_meta":{
|
||||
"openai/ui":{"entrypoints":[{"type":"statusline","resourceUri":URI}]}
|
||||
}});
|
||||
reply.send(Ok(Ok(json!({"data":[{"name":"fixture","httpOrigin":null,"runtimeStatus":"connected",
|
||||
"tools":{"line":tool},"resources":[],"resourceTemplates":[],"authStatus":"unsupported"}],"nextCursor":null})))).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
async fn read(&mut self, uri: &str) -> Reply {
|
||||
self.dispatch().await;
|
||||
let (ClientRequest::McpResourceRead { params, .. }, reply) = self.request().await else {
|
||||
panic!("expected the selected resource read");
|
||||
};
|
||||
assert_eq!(params.uri, uri);
|
||||
reply
|
||||
}
|
||||
|
||||
fn assert_idle(&mut self) {
|
||||
assert!(
|
||||
read_events(&mut self.events).is_empty(),
|
||||
"unexpected reader event"
|
||||
);
|
||||
assert!(
|
||||
self.requests.try_recv().is_err(),
|
||||
"unexpected app-server request"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn respond(reply: Reply, text: &str) {
|
||||
reply
|
||||
.send(Ok(Ok(
|
||||
json!({"contents":[{"uri":URI,"mimeType":"application/json","text":text}]}),
|
||||
)))
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn advance(millis: u64) {
|
||||
tokio::task::yield_now().await;
|
||||
tokio::time::advance(Duration::from_millis(millis)).await;
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_polls_one_second_after_completion_including_empty_content() {
|
||||
let mut reader = Reader::new().await;
|
||||
reader.resolve().await;
|
||||
// A busy TUI can delay the first snapshot without consuming the provider’s read budget.
|
||||
advance(/*millis*/ 6000).await;
|
||||
let first = reader.read(URI).await;
|
||||
advance(/*millis*/ 800).await;
|
||||
reader.assert_idle();
|
||||
let completed = Instant::now();
|
||||
respond(first, r#""ready""#);
|
||||
reader.dispatch().await;
|
||||
assert_eq!(footer(&reader.chat).as_deref(), Some("ready"));
|
||||
|
||||
advance(/*millis*/ 999).await;
|
||||
reader.assert_idle();
|
||||
advance(/*millis*/ 1).await;
|
||||
reader.chat.set_model("updated-model");
|
||||
reader.dispatch().await;
|
||||
let (ClientRequest::McpResourceRead { params, .. }, second) = reader.request().await else {
|
||||
panic!("expected second resource read");
|
||||
};
|
||||
let meta = params.meta.unwrap();
|
||||
assert_eq!(
|
||||
meta["com.openai/codex-statusline-state"]["thread"]["model"]["display_name"],
|
||||
"updated-model"
|
||||
);
|
||||
assert_eq!(completed.elapsed(), Duration::from_secs(1));
|
||||
let completed = Instant::now();
|
||||
respond(second, "null");
|
||||
reader.dispatch().await;
|
||||
assert_eq!(footer(&reader.chat).as_deref(), Some(""));
|
||||
advance(/*millis*/ 999).await;
|
||||
reader.assert_idle();
|
||||
advance(/*millis*/ 1).await;
|
||||
let _third = reader.read(URI).await;
|
||||
assert_eq!(completed.elapsed(), Duration::from_secs(1));
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_invalid_content_stops_polling_immediately() {
|
||||
let mut reader = Reader::new().await;
|
||||
reader.resolve().await;
|
||||
respond(reader.read(URI).await, r#""last good""#);
|
||||
reader.dispatch().await;
|
||||
advance(/*millis*/ 1000).await;
|
||||
|
||||
let invalid = reader.read(URI).await;
|
||||
assert_eq!(footer(&reader.chat).as_deref(), Some("last good"));
|
||||
let failed = Instant::now();
|
||||
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.");
|
||||
reader.chat.refresh_status_line();
|
||||
advance(/*millis*/ 60_000).await;
|
||||
reader.assert_idle();
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_rpc_error_stops_polling_immediately() {
|
||||
let mut reader = Reader::new().await;
|
||||
reader.resolve().await;
|
||||
let resolved = Instant::now();
|
||||
let reply = reader.read(URI).await;
|
||||
assert_eq!(resolved.elapsed(), Duration::ZERO);
|
||||
let failed = Instant::now();
|
||||
reply
|
||||
.send(Err(std::io::Error::other("provider disconnected")))
|
||||
.unwrap();
|
||||
reader.dispatch().await;
|
||||
assert_eq!(failed.elapsed(), Duration::ZERO);
|
||||
assert!(
|
||||
footer(&reader.chat)
|
||||
.unwrap()
|
||||
.contains("Error loading statusline contents from Calendar")
|
||||
);
|
||||
advance(/*millis*/ 60_000).await;
|
||||
reader.assert_idle();
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_returning_to_a_thread_fetches_fresh_state_and_discards_its_old_reply() {
|
||||
let mut reader = Reader::new().await;
|
||||
let original = reader.chat.thread_id.unwrap();
|
||||
reader.resolve().await;
|
||||
let old = reader.read(URI).await;
|
||||
|
||||
reader.chat.thread_id = Some(ThreadId::new());
|
||||
reader.chat.refresh_status_line();
|
||||
reader.dispatch().await;
|
||||
reader.resolve().await;
|
||||
let other = reader.read(URI).await;
|
||||
|
||||
reader.chat.thread_id = Some(original);
|
||||
reader.chat.refresh_status_line();
|
||||
reader.dispatch().await;
|
||||
let returned = Instant::now();
|
||||
reader.resolve().await;
|
||||
let current = reader.read(URI).await;
|
||||
assert_eq!(returned.elapsed(), Duration::ZERO);
|
||||
respond(current, r#""fresh footer""#);
|
||||
reader.dispatch().await;
|
||||
assert_eq!(footer(&reader.chat).as_deref(), Some("fresh footer"));
|
||||
|
||||
let late =
|
||||
json!({"contents":[{"uri":URI,"mimeType":"application/json","text":"\"old footer\""}]});
|
||||
assert!(old.send(Ok(Ok(late.clone()))).is_err());
|
||||
assert!(other.send(Ok(Ok(late))).is_err());
|
||||
advance(/*millis*/ 1000).await;
|
||||
let mut parked = reader.read(URI).await;
|
||||
reader.chat.park_voice();
|
||||
reader.chat.refresh_status_line();
|
||||
parked.closed().await;
|
||||
reader.assert_idle();
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_deadline_wins_when_a_late_reply_is_already_queued() {
|
||||
let mut reader = Reader::new().await;
|
||||
reader.resolve().await;
|
||||
let reply = reader.read(URI).await;
|
||||
// Queue the reply beyond the deadline before letting the reader poll either future.
|
||||
let mut advance = std::pin::pin!(tokio::time::advance(Duration::from_millis(1_001)));
|
||||
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")
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_hung_read_stops_polling_after_one_second() {
|
||||
let mut reader = Reader::new().await;
|
||||
reader.resolve().await;
|
||||
let held = reader.read(URI).await;
|
||||
let started = Instant::now();
|
||||
advance(/*millis*/ 999).await;
|
||||
reader.assert_idle();
|
||||
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!(held.is_closed());
|
||||
advance(/*millis*/ 60_000).await;
|
||||
reader.assert_idle();
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn statusline_startup_timeout_stops_before_the_first_read() {
|
||||
let mut reader = Reader::new().await;
|
||||
let (ClientRequest::ConfigRead { .. }, held) = reader.request().await else {
|
||||
panic!("expected startup lookup");
|
||||
};
|
||||
let started = Instant::now();
|
||||
advance(/*millis*/ 4999).await;
|
||||
reader.assert_idle();
|
||||
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!(held.is_closed());
|
||||
reader.chat.refresh_status_line();
|
||||
advance(/*millis*/ 60_000).await;
|
||||
reader.assert_idle();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user