mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
## What changed Add `codex.statusline.provider_started` and `codex.statusline.provider_failed` counters through the existing status line metrics collector. Classify failures with `kind=timeout` or `kind=error`, and ignore events from stale readers. ## Testing Extend reader and picker tests to check counters for explicit selection, polling, invalid content, timeouts, restarts, and stale events. GitOrigin-RevId: 8c3074743f3b31409ccd713edb228e4dce809ea8
332 lines
12 KiB
Rust
332 lines
12 KiB
Rust
//! 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;
|
||
use crate::app_event_sender::AppEventSender;
|
||
use crate::app_server_session::AppServerSession;
|
||
use crate::backend_id::BackendId;
|
||
use crate::legacy_core::config::Config;
|
||
use crate::statusline_metrics::StatuslineMetrics;
|
||
use crate::statusline_provider::LOOKUP_TIMEOUT;
|
||
use crate::statusline_provider::ProviderId;
|
||
use crate::statusline_provider::ProviderLookupError;
|
||
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_config::types::StatusLineProviderId;
|
||
use codex_config::types::StatusLineSelection;
|
||
use codex_features::Feature;
|
||
use codex_protocol::ThreadId;
|
||
use codex_utils_path_uri::LegacyAppPathString;
|
||
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_at;
|
||
use tokio_util::sync::CancellationToken;
|
||
use uuid::Uuid;
|
||
|
||
pub(super) struct ActiveStatuslineRead {
|
||
token: Uuid,
|
||
thread: Option<ThreadId>,
|
||
selection: ProviderId,
|
||
provider_from_picker: Option<StatuslineProvider>,
|
||
host_cwd: PathBuf,
|
||
startup: watch::Sender<()>,
|
||
cancel: CancellationToken,
|
||
}
|
||
|
||
impl Drop for ActiveStatuslineRead {
|
||
fn drop(&mut self) {
|
||
self.cancel.cancel();
|
||
}
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
pub(crate) struct StatuslineReadEvent {
|
||
token: Uuid,
|
||
step: ReadStep,
|
||
}
|
||
|
||
#[derive(derive_more::Debug)]
|
||
enum ReadStep {
|
||
Start(watch::Receiver<()>),
|
||
#[debug("Snapshot(..)")]
|
||
Snapshot(BackendId, oneshot::Sender<StatuslineState>),
|
||
#[debug("Finished(..)")]
|
||
Finished(BackendId, Result<UiTree, Failure>),
|
||
}
|
||
|
||
impl StatuslineReadEvent {
|
||
fn send(sender: &AppEventSender, token: Uuid, step: ReadStep) {
|
||
sender.send(AppEvent::StatuslineRead(Self { token, step }));
|
||
}
|
||
}
|
||
|
||
impl ChatWidget {
|
||
pub(crate) fn selected_statusline_provider(&self) -> Option<&StatusLineProviderId> {
|
||
if self.statusline_disconnected
|
||
|| self.read_only_history
|
||
|| self
|
||
.app_event_tx
|
||
.voice_only
|
||
.load(std::sync::atomic::Ordering::Relaxed)
|
||
|| !self
|
||
.config
|
||
.features
|
||
.enabled(Feature::TuiExtensionsStatusLine)
|
||
{
|
||
return None;
|
||
}
|
||
self.configured_statusline_provider()
|
||
}
|
||
|
||
pub(crate) fn configured_statusline_provider(&self) -> Option<&StatusLineProviderId> {
|
||
match self.local_settings.tui.status_line_provider.as_deref()? {
|
||
StatusLineSelection::Builtin(_) => None,
|
||
StatusLineSelection::Mcp(id) => Some(id),
|
||
}
|
||
}
|
||
|
||
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();
|
||
}
|
||
|
||
pub(super) fn refresh_provider_footer(&mut self) -> bool {
|
||
let Some(selection) = self.selected_statusline_provider() else {
|
||
self.statusline_read = None;
|
||
return false;
|
||
};
|
||
if self
|
||
.statusline_read
|
||
.as_ref()
|
||
.is_some_and(|read| read.is_current(self))
|
||
{
|
||
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,
|
||
provider_from_picker,
|
||
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(
|
||
UiTree(Some(UiNode::String("Initializing…".into()))).into(),
|
||
));
|
||
if self.thread_id.is_some() {
|
||
StatuslineReadEvent::send(&self.app_event_tx, token, ReadStep::Start(ready));
|
||
}
|
||
}
|
||
|
||
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(
|
||
&mut self,
|
||
event: StatuslineReadEvent,
|
||
owner: &AppServerSession,
|
||
metrics: &StatuslineMetrics,
|
||
config: &Config,
|
||
) {
|
||
let Some(footer) = self
|
||
.statusline_read
|
||
.as_ref()
|
||
.filter(|read| read.token == event.token)
|
||
else {
|
||
return;
|
||
};
|
||
if !footer.is_current(self) {
|
||
self.refresh_status_line();
|
||
return;
|
||
}
|
||
match event.step {
|
||
ReadStep::Start(ready) => {
|
||
metrics.record(config, "codex.statusline.provider_started", &[]);
|
||
footer.start(owner, &self.app_event_tx, ready);
|
||
}
|
||
ReadStep::Snapshot(backend, reply) => {
|
||
if backend == owner.backend_id()
|
||
&& let Some(state) = self.statusline_state()
|
||
{
|
||
let _ = reply.send(state);
|
||
}
|
||
}
|
||
ReadStep::Finished(backend, result) => {
|
||
if backend != owner.backend_id() {
|
||
return;
|
||
}
|
||
let tree = match result {
|
||
Ok(tree) => tree,
|
||
Err(failure) => {
|
||
metrics.record(
|
||
config,
|
||
"codex.statusline.provider_failed",
|
||
&[("kind", failure.metric_kind())],
|
||
);
|
||
footer.cancel.cancel();
|
||
tracing::warn!(?failure, "Status line provider stopped");
|
||
let message = match failure {
|
||
Failure::LookupTimedOut | Failure::Read(ReadIssue::TimedOut) => {
|
||
"Status line timed out"
|
||
}
|
||
Failure::LookupUnavailable => "Status line unavailable",
|
||
Failure::Snapshot | Failure::Read(_) => "Status line failed",
|
||
};
|
||
UiTree(Some(UiNode::String(format!("{message} · /statusline"))))
|
||
}
|
||
};
|
||
self.set_status_line(Some(tree.into()));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
impl ActiveStatuslineRead {
|
||
fn is_current(&self, chat: &ChatWidget) -> bool {
|
||
self.thread == chat.thread_id
|
||
&& 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.as_str() == server {
|
||
self.startup.send_replace(());
|
||
}
|
||
}
|
||
|
||
fn start(
|
||
&self,
|
||
owner: &AppServerSession,
|
||
events: &AppEventSender,
|
||
mut ready: watch::Receiver<()>,
|
||
) {
|
||
let Some(thread) = self.thread else { return };
|
||
let id = self.selection.clone();
|
||
let provider_from_picker = self.provider_from_picker.clone();
|
||
let token = self.token;
|
||
let events = events.clone();
|
||
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: Option<Result<(), Failure>> = cancel
|
||
.run_until_cancelled(async {
|
||
let cwd = cwd.ok_or(Failure::LookupUnavailable)?;
|
||
let deadline = Instant::now() + LOOKUP_TIMEOUT;
|
||
let provider = loop {
|
||
let choice = provider_from_picker
|
||
.as_ref()
|
||
.map_or(ProviderSelection::Saved(&id), ProviderSelection::Discovered);
|
||
match ResolvedStatuslineProvider::lookup(
|
||
&client, thread, &cwd, choice, deadline,
|
||
)
|
||
.await
|
||
{
|
||
Ok(Some(provider)) => break provider,
|
||
Err(ProviderLookupError::TimedOut) => {
|
||
return Err(Failure::LookupTimedOut);
|
||
}
|
||
Ok(None) | Err(ProviderLookupError::Request(_)) => {}
|
||
}
|
||
// A cold catalog can arrive before this server finishes starting.
|
||
if !matches!(timeout_at(deadline, ready.changed()).await, Ok(Ok(())))
|
||
|| Instant::now() >= deadline
|
||
{
|
||
return Err(Failure::LookupUnavailable);
|
||
}
|
||
};
|
||
loop {
|
||
let (reply, snapshot) = oneshot::channel();
|
||
StatuslineReadEvent::send(
|
||
&events,
|
||
token,
|
||
ReadStep::Snapshot(backend, reply),
|
||
);
|
||
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.map_err(ReadIssue::from)?
|
||
}
|
||
Ok(_) | Err(_) => return Err(ReadIssue::TimedOut.into()),
|
||
};
|
||
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;
|
||
if let Some(Err(failure)) = result {
|
||
StatuslineReadEvent::send(
|
||
&events,
|
||
token,
|
||
ReadStep::Finished(backend, Err(failure)),
|
||
);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[path = "statusline_reader_tests.rs"]
|
||
mod tests;
|