diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index f5b81aba77..de789e0694 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -859,7 +859,7 @@ impl App { feedback: self.feedback.clone(), is_first_run: false, status_account_display: self.chat_widget.status_account_display().cloned(), - initial_plan_type: self.chat_widget.current_plan_type(), + initial_plan_type: self.chat_widget.account_plan, model: Some(self.chat_widget.current_model().to_string()), startup_tooltip_override: None, status_line_invalid_items_warned: self.status_line_invalid_items_warned.clone(), diff --git a/codex-rs/tui/src/app/account_status.rs b/codex-rs/tui/src/app/account_status.rs index 4895b230df..944950586a 100644 --- a/codex-rs/tui/src/app/account_status.rs +++ b/codex-rs/tui/src/app/account_status.rs @@ -34,12 +34,13 @@ impl App { if let Some(Account::Chatgpt { email, workspace_name, - .. + plan_type, }) = response.account { app_event_tx.send(AppEvent::AccountEmailLoaded { request_id, email, + plan_type, workspace: crate::app_server_session::workspace_display( workspace_name, response.workspace_routing, diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index 49e90c2d1b..86052f49a2 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -1654,10 +1654,10 @@ impl App { elicitation_target: None, }); } - AppEvent::AccountEmailLoaded { request_id, email, workspace } => { + AppEvent::AccountEmailLoaded { request_id, email, workspace, plan_type } => { if self.account_email_request_id == Some(request_id) { self.account_email_request_id = None; - self.chat_widget.on_account_email_loaded(email, workspace); + self.chat_widget.on_account_email_loaded(email, workspace, plan_type); } } AppEvent::SecuritySetupLoaded { request_id, identity, notice } => { @@ -2217,7 +2217,12 @@ impl App { self.chat_widget.apply_usage_notice_read(request_id); self.chat_widget.update_backend_banner(&response); self.apply_backend_banner_fallback(app_server).await; - app_server_rate_limit_snapshots(response) + let snapshots = app_server_rate_limit_snapshots(response); + // The account can outlive the popup or chat that requested this read. + for snapshot in &snapshots { + self.chat_widget.observe_quota_plan(snapshot); + } + snapshots } else { Vec::new() }; diff --git a/codex-rs/tui/src/app/tests/new_session_tests.rs b/codex-rs/tui/src/app/tests/new_session_tests.rs index 96338a1f38..442c08edfa 100644 --- a/codex-rs/tui/src/app/tests/new_session_tests.rs +++ b/codex-rs/tui/src/app/tests/new_session_tests.rs @@ -87,6 +87,7 @@ async fn new_session_refreshes_account_for_the_started_provider() -> Result<()> /*spend_control_reached*/ None, ); snapshot.credits = None; + snapshot.plan_type = Some(codex_protocol::account::PlanType::Business); app.chat_widget .on_rate_limit_snapshot(Some(snapshot.clone())); if provider == "alt" { diff --git a/codex-rs/tui/src/app/tests/rate_limits.rs b/codex-rs/tui/src/app/tests/rate_limits.rs index c8acbadcf7..6b886f2a2e 100644 --- a/codex-rs/tui/src/app/tests/rate_limits.rs +++ b/codex-rs/tui/src/app/tests/rate_limits.rs @@ -156,6 +156,64 @@ async fn backend_banner_state_survives_widget_replacement() -> Result<()> { Ok(()) } +#[tokio::test] +async fn accepted_rate_limit_read_updates_billing_after_its_status_card_is_gone() -> Result<()> { + use codex_protocol::account::PlanType; + + let (mut app, mut events, _) = make_test_app_with_channels().await; + let mut tui = crate::tui::test_support::make_test_tui()?; + let mut server = + crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?; + let card_id = 1; + app.chat_widget + .add_status_output(/*refreshing_rate_limits*/ true, Some(card_id)); + let origin = RateLimitRefreshOrigin::StatusCommand { + request_id: card_id, + }; + let (request_id, hard_stop_generation) = app + .rate_limit_refresh_state + .start(origin, &mut app.rate_limit_hard_stop_generation) + .unwrap(); + let mut replacement = app.chatwidget_init_for_forked_or_resumed_thread( + &mut tui, + app.config.clone(), + /*initial_user_message*/ None, + ); + replacement.has_codex_backend_auth = true; + replacement.initial_plan_type = Some(PlanType::Plus); + replacement.local_settings.tui.status_line = Some(vec!["estimated-thread-cost".into()]); + app.replace_chat_widget(ChatWidget::new_with_app_event(replacement)); + let thread = ThreadId::new(); + app.enqueue_primary_thread_session( + test_thread_session(thread, app.config.cwd.to_path_buf()), + Vec::new(), + ) + .await?; + app.drain_active_thread_events(&mut tui).await?; + while events.try_recv().is_ok() {} + + let quota = serde_json::from_value(serde_json::json!({"planType": "business"}))?; + Box::pin(app.handle_event( + &mut tui, + &mut server, + AppEvent::RateLimitsLoaded { + request_id, + origin, + hard_stop_generation, + result: Ok(account_rate_limits_response(quota)), + }, + )) + .await?; + assert_eq!( + app.chat_widget.current_plan_type(), + Some(PlanType::Business) + ); + assert!(std::iter::from_fn(|| events.try_recv().ok()).any(|event| + matches!(event, AppEvent::RefreshThreadUsage { thread_id, .. } if thread_id == thread))); + server.shutdown().await?; + Ok(()) +} + #[tokio::test] async fn rolling_workspace_hard_stops_invalidate_older_rate_limit_reads() -> Result<()> { let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; diff --git a/codex-rs/tui/src/app/tests/security_setup_tests.rs b/codex-rs/tui/src/app/tests/security_setup_tests.rs index 1e2f9be518..c9a174b014 100644 --- a/codex-rs/tui/src/app/tests/security_setup_tests.rs +++ b/codex-rs/tui/src/app/tests/security_setup_tests.rs @@ -173,6 +173,7 @@ async fn security_setup_fetch_with_default_features_uses_authenticated_codex_end request_id: uuid::Uuid::new_v4(), email: Some("stale@example.com".into()), workspace: Some("stale-account".into()), + plan_type: codex_protocol::account::PlanType::Plus, }, ) .await?; diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index 883e95c471..9dda018b09 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -358,6 +358,7 @@ pub(crate) enum AppEvent { request_id: uuid::Uuid, email: Option, workspace: Option, + plan_type: codex_protocol::account::PlanType, }, SecuritySetupLoaded { request_id: uuid::Uuid, diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index b852784026..8368a7d839 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -599,6 +599,8 @@ pub(crate) struct ChatWidget { pending_rate_limit_reset_hint: Option, available_rate_limit_reset_credits: Option, next_rate_limit_reset_request_id: u64, + pub(crate) account_plan: Option, + quota_plan: Option, plan_type: Option, codex_rate_limit_reached_type: Option, codex_spend_control_reached: Option, diff --git a/codex-rs/tui/src/chatwidget/backend_banners.rs b/codex-rs/tui/src/chatwidget/backend_banners.rs index 704446e92a..1bff1eaf56 100644 --- a/codex-rs/tui/src/chatwidget/backend_banners.rs +++ b/codex-rs/tui/src/chatwidget/backend_banners.rs @@ -302,6 +302,8 @@ impl ChatWidget { self.inherited_quota_provider = Some(previous.quota_provider_id().to_owned()); self.rate_limit_snapshots_by_limit_id = std::mem::take(&mut previous.rate_limit_snapshots_by_limit_id); + self.quota_plan = previous.quota_plan.take(); + self.refresh_billing_plan(); self.usage_notice_state = std::mem::take(&mut previous.usage_notice_state); self.codex_rate_limit_reached_type = previous.codex_rate_limit_reached_type; self.codex_spend_control_reached = previous.codex_spend_control_reached; diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rs index d1a95aeae9..abd4ec7652 100644 --- a/codex-rs/tui/src/chatwidget/constructor.rs +++ b/codex-rs/tui/src/chatwidget/constructor.rs @@ -171,6 +171,8 @@ impl ChatWidget { pending_rate_limit_reset_hint: None, available_rate_limit_reset_credits: None, next_rate_limit_reset_request_id: 0, + account_plan: initial_plan_type, + quota_plan: None, plan_type: initial_plan_type, codex_rate_limit_reached_type: None, codex_spend_control_reached: None, diff --git a/codex-rs/tui/src/chatwidget/rate_limits.rs b/codex-rs/tui/src/chatwidget/rate_limits.rs index e0eeb4b737..12c0daa18b 100644 --- a/codex-rs/tui/src/chatwidget/rate_limits.rs +++ b/codex-rs/tui/src/chatwidget/rate_limits.rs @@ -252,9 +252,27 @@ impl ChatWidget { } pub(crate) fn on_rate_limit_snapshot(&mut self, snapshot: Option) { + if let Some(snapshot) = &snapshot { + self.observe_quota_plan(snapshot); + } self.on_rate_limit_snapshot_from(snapshot, RateLimitSnapshotSource::AccountUsage); } + pub(crate) fn observe_quota_plan(&mut self, snapshot: &RateLimitSnapshot) { + if snapshot + .limit_id + .as_deref() + .is_none_or(|id| id.eq_ignore_ascii_case("codex")) + && let Some(plan) = snapshot.plan_type.filter(|plan| *plan != PlanType::Unknown) + { + self.quota_plan = Some(plan); + if self.plan_type != Some(plan) { + self.refresh_billing_plan(); + self.refresh_status_surfaces(); + } + } + } + pub(crate) fn on_rolling_rate_limit_snapshot(&mut self, snapshot: RateLimitSnapshot) { if let (Some(previous), Some(current)) = ( self.codex_rate_limit_reached_type, @@ -302,8 +320,6 @@ impl ChatWidget { balance: credits.balance.clone(), }); } - self.plan_type = snapshot.plan_type.or(self.plan_type); - if is_codex_limit && (matches!(source, RateLimitSnapshotSource::AccountUsage) || snapshot.spend_control_reached.is_some()) @@ -422,6 +438,8 @@ impl ChatWidget { } } else { self.rate_limit_snapshots_by_limit_id.clear(); + self.quota_plan = None; + self.refresh_billing_plan(); self.codex_rate_limit_reached_type = None; self.codex_spend_control_reached = None; } diff --git a/codex-rs/tui/src/chatwidget/settings.rs b/codex-rs/tui/src/chatwidget/settings.rs index 9d40377898..a1345c5954 100644 --- a/codex-rs/tui/src/chatwidget/settings.rs +++ b/codex-rs/tui/src/chatwidget/settings.rs @@ -223,6 +223,7 @@ impl ChatWidget { &mut self, current_email: Option, current_workspace: Option, + plan_type: PlanType, ) { if let Some(StatusAccountDisplay::ChatGpt { email, workspace, .. @@ -230,6 +231,9 @@ impl ChatWidget { { *email = current_email; *workspace = current_workspace; + self.account_plan = Some(plan_type); + self.refresh_billing_plan(); + self.refresh_status_surfaces(); } } @@ -287,6 +291,8 @@ impl ChatWidget { self.status_line_workspace_messages_disabled = false; self.clear_thread_usage_state(); self.status_account_display = status_account_display; + self.account_plan = plan_type; + self.quota_plan = None; self.plan_type = plan_type; self.has_chatgpt_account = has_chatgpt_account; if api_key_changed { diff --git a/codex-rs/tui/src/chatwidget/status_controls.rs b/codex-rs/tui/src/chatwidget/status_controls.rs index 53df874062..00774c1e87 100644 --- a/codex-rs/tui/src/chatwidget/status_controls.rs +++ b/codex-rs/tui/src/chatwidget/status_controls.rs @@ -275,7 +275,7 @@ impl ChatWidget { } if self.thread_usage_is_available() { handle.reserve_thread_usage_label_width(); - handle.set_thread_usage(self.estimated_thread_usage().cloned()); + handle.set_thread_usage(self.estimated_thread_usage().cloned(), self.plan_type); self.add_to_history(cell); self.request_thread_usage_for_status(handle.clone()); } else { @@ -306,38 +306,25 @@ impl ChatWidget { request_id: u64, snapshots: Vec, ) { - if !self + let Some(index) = self .refreshing_status_outputs .iter() - .any(|(pending_request_id, _)| *pending_request_id == request_id) - { + .position(|(pending_request_id, _)| *pending_request_id == request_id) + else { return; - } - + }; for snapshot in snapshots { self.on_rate_limit_snapshot(Some(snapshot)); } + let (_, handle) = self.refreshing_status_outputs.swap_remove(index); let rate_limit_snapshots: Vec = self .rate_limit_snapshots_by_limit_id .values() .cloned() .collect(); - let now = Local::now(); - let mut remaining = Vec::with_capacity(self.refreshing_status_outputs.len()); - let mut updated_any = false; - for (pending_request_id, handle) in self.refreshing_status_outputs.drain(..) { - if pending_request_id == request_id { - updated_any = true; - handle.finish_rate_limit_refresh(rate_limit_snapshots.as_slice(), now); - } else { - remaining.push((pending_request_id, handle)); - } - } - self.refreshing_status_outputs = remaining; - if updated_any { - self.request_redraw(); - } + handle.finish_rate_limit_refresh(&rate_limit_snapshots, Local::now()); + self.request_redraw(); } pub(super) fn open_status_line_setup(&mut self) { diff --git a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs index b945dbc557..917f1ad904 100644 --- a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs +++ b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs @@ -1333,6 +1333,10 @@ async fn rate_limit_snapshot_updates_and_retains_plan_type() { rate_limit_reached_type: None, })); assert_eq!(chat.plan_type, Some(PlanType::Pro)); + + let unknown = serde_json::from_value(serde_json::json!({"planType": "unknown"})).unwrap(); + chat.on_rate_limit_snapshot(Some(unknown)); + assert_eq!(chat.plan_type, Some(PlanType::Pro)); } #[tokio::test] diff --git a/codex-rs/tui/src/chatwidget/thread_usage.rs b/codex-rs/tui/src/chatwidget/thread_usage.rs index c896163ab1..4a92e6fcdd 100644 --- a/codex-rs/tui/src/chatwidget/thread_usage.rs +++ b/codex-rs/tui/src/chatwidget/thread_usage.rs @@ -56,6 +56,25 @@ pub(super) struct ThreadUsageState { } impl ChatWidget { + pub(super) fn refresh_billing_plan(&mut self) { + // A full quota read reflects the current subscription; account/read can use a cached token. + let plan = self.quota_plan.or(self.account_plan); + if self.plan_type == plan { + return; + } + let previously_available = self.thread_usage_is_available(); + self.plan_type = plan; + if !self.thread_usage_is_available() { + self.clear_thread_usage_state(); + } else if !previously_available { + // A pending /status can learn that the account is billable from its own quota read. + for (_, handle) in self.refreshing_status_outputs.clone() { + handle.reserve_thread_usage_label_width(); + self.request_thread_usage_for_status(handle); + } + } + } + pub(super) fn clear_thread_usage_state(&mut self) { self.thread_usage = ThreadUsageState::default(); } @@ -299,7 +318,7 @@ impl ChatWidget { } if usage_updated && !self.thread_usage.status_history_handles.is_empty() { for handle in &self.thread_usage.status_history_handles { - handle.set_thread_usage(self.thread_usage.estimate.clone()); + handle.set_thread_usage(self.thread_usage.estimate.clone(), self.plan_type); } if self .thread_usage diff --git a/codex-rs/tui/src/chatwidget/thread_usage_tests.rs b/codex-rs/tui/src/chatwidget/thread_usage_tests.rs index 333b2eb62f..49236268f0 100644 --- a/codex-rs/tui/src/chatwidget/thread_usage_tests.rs +++ b/codex-rs/tui/src/chatwidget/thread_usage_tests.rs @@ -69,6 +69,115 @@ async fn replacement_widget_rejects_a_previous_widgets_read_for_the_same_thread( assert!(replacement.is_pending_thread_usage(thread, current)); } +#[tokio::test] +async fn billing_prefers_a_known_quota_plan_in_either_reply_order() { + for (account, quota_plan, expected) in [ + (PlanType::Plus, PlanType::Business, PlanType::Business), + (PlanType::Unknown, PlanType::Business, PlanType::Business), + (PlanType::Business, PlanType::Unknown, PlanType::Business), + ] { + for quota_first in [true, false] { + let (mut chat, ..) = make_chatwidget_manual_with_sender().await; + chat.status_account_display = Some(crate::status::StatusAccountDisplay::ChatGpt { + email: None, + plan: None, + workspace: None, + }); + let quota = + serde_json::from_value(serde_json::json!({"planType": quota_plan})).unwrap(); + let account_read = |chat: &mut ChatWidget| { + chat.on_account_email_loaded( + /*current_email*/ None, /*current_workspace*/ None, account, + ); + }; + if quota_first { + chat.on_rate_limit_snapshot(Some(quota)); + account_read(&mut chat); + } else { + account_read(&mut chat); + assert_eq!(chat.current_plan_type(), Some(account)); + chat.on_rate_limit_snapshot(Some(quota)); + } + assert_eq!(chat.current_plan_type(), Some(expected)); + } + } +} + +#[tokio::test] +async fn pending_status_card_uses_the_corrected_plan_for_its_usage_reply() { + let mut rows = Vec::new(); + for original_plan in [PlanType::Business, PlanType::Plus] { + let (mut chat, _, mut events, _) = make_chatwidget_manual_with_sender().await; + let thread = ThreadId::new(); + chat.thread_id = Some(thread); + chat.has_codex_backend_auth = true; + chat.plan_type = Some(original_plan); + let status_request = 1; + chat.add_status_output(/*refreshing_rate_limits*/ true, Some(status_request)); + let AppEvent::InsertHistoryCell(card) = events.try_recv().unwrap() else { + panic!("expected a /status card"); + }; + let corrected_ent26 = + serde_json::from_value(serde_json::json!({"planType": PlanType::Ent26})).unwrap(); + chat.finish_status_rate_limit_refresh(status_request, vec![corrected_ent26]); + let usage = ThreadUsage { + native_usage_usd_micros: Some(1_800_000), + ..thread_usage( + thread, + /*estimated_usage_credits_micros*/ 50_000_000, + Some(2_000_000), + ) + }; + let request = thread_usage_request_id(&mut events); + assert!(chat.finish_thread_usage_refresh( + thread, + request, + Ok(ThreadUsageOutcome::Available(usage)) + )); + let row = card + .display_lines(/*width*/ 90) + .into_iter() + .map(|line| line.to_string()) + .find(|line| line.contains("Thread usage:")) + .unwrap(); + rows.push(format!("{original_plan:?} → Ent26: {}", row.trim())); + } + insta::assert_snapshot!(rows.join("\n"), @r" + Business → Ent26: Thread usage: ~$1.80 + Plus → Ent26: Thread usage: ~$1.80 + "); +} + +#[tokio::test] +async fn rolling_quota_cannot_restore_an_obsolete_billing_plan() { + let (mut chat, _, mut events, _) = make_chatwidget_manual_with_sender().await; + let thread = ThreadId::new(); + chat.thread_id = Some(thread); + chat.has_codex_backend_auth = true; + chat.local_settings.tui.status_line = Some(vec!["estimated-thread-cost".into()]); + chat.status_account_display = Some(crate::status::StatusAccountDisplay::ChatGpt { + email: None, + plan: None, + workspace: None, + }); + chat.on_account_email_loaded( + /*current_email*/ None, + /*current_workspace*/ None, + PlanType::Business, + ); + let pending = thread_usage_request_id(&mut events); + chat.on_account_email_loaded( + /*current_email*/ None, + /*current_workspace*/ None, + PlanType::Plus, + ); + let rolling = serde_json::from_value(serde_json::json!({"planType": "business"})).unwrap(); + chat.on_rolling_rate_limit_snapshot(rolling); + + assert_eq!(chat.current_plan_type(), Some(PlanType::Plus)); + assert!(!chat.finish_thread_usage_refresh(thread, pending, Ok(ThreadUsageOutcome::Disabled))); +} + #[test] fn estimated_cost_formats_dollars_and_sub_cent_values() { assert_eq!( diff --git a/codex-rs/tui/src/status/card.rs b/codex-rs/tui/src/status/card.rs index 8145011fd1..d18a3059fe 100644 --- a/codex-rs/tui/src/status/card.rs +++ b/codex-rs/tui/src/status/card.rs @@ -119,8 +119,9 @@ impl StatusHistoryHandle { pub(crate) fn set_thread_usage( &self, estimate: Option, + plan: Option, ) { - self.card.thread_usage.set_estimate(estimate); + self.card.thread_usage.set_estimate(estimate, plan); } } @@ -142,7 +143,6 @@ struct StatusHistoryCell { token_usage: StatusTokenUsageData, rate_limit_state: Arc>, thread_usage: StatusThreadUsage, - plan_type: Option, } #[cfg(test)] @@ -422,7 +422,6 @@ impl StatusHistoryCell { agents_summary, rate_limit_state, thread_usage, - plan_type: _plan_type, } } @@ -897,9 +896,7 @@ impl StatusHistoryCell { } lines.extend(self.rate_limit_lines(&rate_limit_state, available_width, &formatter)); - let thread_usage_lines = self - .thread_usage - .lines(&formatter, value_width, self.plan_type); + let thread_usage_lines = self.thread_usage.lines(&formatter, value_width); if !thread_usage_lines.is_empty() { lines.push(Line::from(Vec::>::new())); lines.extend(thread_usage_lines); diff --git a/codex-rs/tui/src/status/thread_usage.rs b/codex-rs/tui/src/status/thread_usage.rs index ef419ad252..d0d94c00b6 100644 --- a/codex-rs/tui/src/status/thread_usage.rs +++ b/codex-rs/tui/src/status/thread_usage.rs @@ -12,7 +12,6 @@ use ratatui::prelude::Line; use ratatui::style::Stylize; use std::collections::BTreeMap; use std::collections::BTreeSet; -use std::sync::Arc; use std::sync::RwLock; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; @@ -43,10 +42,16 @@ pub(crate) fn thread_cost_micros(usage: &ThreadUsage, plan_type: Option>>, - reserve_label_width: Arc, + billing: RwLock, + reserve_label_width: AtomicBool, +} + +#[derive(Debug, Default)] +struct CardBilling { + estimate: Option, + plan: Option, } impl StatusThreadUsage { @@ -55,13 +60,13 @@ impl StatusThreadUsage { .store(/*val*/ true, Ordering::Relaxed); } - pub(crate) fn set_estimate(&self, estimate: Option) { + pub(crate) fn set_estimate(&self, estimate: Option, plan: Option) { #[expect(clippy::expect_used)] - let mut stored_estimate = self - .estimate + let mut billing = self + .billing .write() .expect("status history thread-usage state poisoned"); - *stored_estimate = estimate; + *billing = CardBilling { estimate, plan }; } pub(crate) fn push_labels(&self, labels: &mut Vec, seen: &mut BTreeSet) { @@ -71,11 +76,11 @@ impl StatusThreadUsage { push_label(labels, seen, BILLED_TOKENS_LABEL); } #[expect(clippy::expect_used)] - let stored_estimate = self - .estimate + let billing = self + .billing .read() .expect("status history thread-usage state poisoned"); - let Some(estimate) = stored_estimate.as_ref() else { + let Some(estimate) = billing.estimate.as_ref() else { return; }; push_label(labels, seen, "Thread usage"); @@ -97,20 +102,19 @@ impl StatusThreadUsage { &self, formatter: &FieldFormatter, value_width: usize, - plan_type: Option, ) -> Vec> { #[expect(clippy::expect_used)] - let stored_estimate = self - .estimate + let billing = self + .billing .read() .expect("status history thread-usage state poisoned"); - let Some(estimate) = stored_estimate.as_ref() else { + let Some(estimate) = billing.estimate.as_ref() else { return Vec::new(); }; - if plan_type == Some(PlanType::Ent26) { + if billing.plan == Some(PlanType::Ent26) { // Credit-weighted breakdowns do not describe native dollar usage. - return thread_cost_micros(estimate, plan_type) + return thread_cost_micros(estimate, billing.plan) .and_then(format_estimated_usd_micros) .map(|cost| vec![formatter.line("Thread usage", vec![cost.into()])]) .unwrap_or_default();