mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
## Why A replacement chat widget can receive a previous widget's usage result for the same thread. Statusline state also lacks the estimated costs available in the built-in status line. ## What changed - Add optional `thread.usage.cost.total_cost_usd` and `total_credits` fields, using the built-in status line's plan-specific values. Convert micro-units to ordinary units and omit unavailable or negative values. - Use UUIDs for thread usage requests and verify that each request is still pending before fetching usage or accepting its result. ## Testing Add regression coverage for rejecting a previous widget's usage result and assertions for serialized costs across supported enterprise plans. GitOrigin-RevId: 91c3f7cead0249b673979d17cc108ceae1088df2
440 lines
17 KiB
Rust
440 lines
17 KiB
Rust
//! Demand-driven estimated-cost state for the currently visible enterprise thread.
|
|
|
|
use super::AppEvent;
|
|
use super::ChatWidget;
|
|
use super::Duration;
|
|
use super::Instant;
|
|
use super::PlanType;
|
|
use super::StatusLineItem;
|
|
use super::TerminalTitleItem;
|
|
use super::ThreadId;
|
|
use crate::status::StatusHistoryHandle;
|
|
use crate::status::thread_cost_micros;
|
|
use codex_app_server_protocol::ThreadUsage;
|
|
use uuid::Uuid;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub(crate) enum ThreadUsageOutcome {
|
|
Available(ThreadUsage),
|
|
Disabled,
|
|
}
|
|
|
|
const THREAD_USAGE_SETTLEMENT_DELAYS: [Duration; 3] = [
|
|
Duration::from_secs(/*secs*/ 15),
|
|
Duration::from_secs(/*secs*/ 60),
|
|
Duration::from_secs(/*secs*/ 120),
|
|
];
|
|
const THREAD_USAGE_RETRY_DELAYS: [Duration; 3] = [
|
|
Duration::from_secs(/*secs*/ 5),
|
|
Duration::from_secs(/*secs*/ 15),
|
|
Duration::from_secs(/*secs*/ 60),
|
|
];
|
|
|
|
#[derive(Debug, Default)]
|
|
struct SelectedThreadUsage {
|
|
credits: bool,
|
|
estimated_cost: bool,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub(super) struct ThreadUsageState {
|
|
thread_id: Option<ThreadId>,
|
|
estimate: Option<ThreadUsage>,
|
|
pending_request_id: Option<Uuid>,
|
|
requested: bool,
|
|
feature_disabled: bool,
|
|
status_history_handles: Vec<StatusHistoryHandle>,
|
|
status_requested: bool,
|
|
retry_attempts: usize,
|
|
retry_due_at: Option<Instant>,
|
|
settlement_attempts: usize,
|
|
settlement_baseline_credits_micros: Option<i64>,
|
|
settlement_baseline_usd_micros: Option<i64>,
|
|
settlement_request_id: Option<Uuid>,
|
|
settlement_refresh_due_at: Option<Instant>,
|
|
pub(super) replaying_turn_completion: bool,
|
|
}
|
|
|
|
impl ChatWidget {
|
|
pub(super) fn clear_thread_usage_state(&mut self) {
|
|
self.thread_usage = ThreadUsageState::default();
|
|
}
|
|
|
|
pub(super) fn ensure_thread_usage_requested(&mut self) {
|
|
let Some(thread_id) = self.thread_id else {
|
|
return;
|
|
};
|
|
if self.thread_usage.thread_id != Some(thread_id) {
|
|
self.clear_thread_usage_state();
|
|
self.thread_usage.thread_id = Some(thread_id);
|
|
}
|
|
if self.thread_usage.requested {
|
|
return;
|
|
}
|
|
self.request_thread_usage();
|
|
}
|
|
|
|
pub(super) fn refresh_thread_usage_after_turn(&mut self) {
|
|
if self.thread_usage.replaying_turn_completion
|
|
|| !self.thread_usage_is_selected()
|
|
|| !self.thread_usage_is_available()
|
|
{
|
|
return;
|
|
}
|
|
|
|
self.thread_usage.settlement_attempts = 0;
|
|
self.thread_usage.settlement_request_id = None;
|
|
self.thread_usage.settlement_baseline_credits_micros = Some(
|
|
self.thread_usage
|
|
.estimate
|
|
.as_ref()
|
|
.map(|estimate| estimate.estimated_usage_credits_micros)
|
|
.unwrap_or_default(),
|
|
);
|
|
self.thread_usage.settlement_baseline_usd_micros = self
|
|
.thread_usage
|
|
.estimate
|
|
.as_ref()
|
|
.and_then(|estimate| thread_cost_micros(estimate, self.plan_type));
|
|
self.schedule_next_thread_usage_settlement();
|
|
self.request_thread_usage();
|
|
}
|
|
|
|
pub(super) fn refresh_thread_usage_if_settlement_due(&mut self) {
|
|
let now = Instant::now();
|
|
let settlement_due = self
|
|
.thread_usage
|
|
.settlement_refresh_due_at
|
|
.is_some_and(|due_at| now >= due_at);
|
|
let retry_due = self
|
|
.thread_usage
|
|
.retry_due_at
|
|
.is_some_and(|due_at| now >= due_at);
|
|
if !settlement_due && !retry_due {
|
|
if let Some(next_due_at) = [
|
|
self.thread_usage.settlement_refresh_due_at,
|
|
self.thread_usage.retry_due_at,
|
|
]
|
|
.into_iter()
|
|
.flatten()
|
|
.min()
|
|
{
|
|
self.frame_requester
|
|
.schedule_frame_in(next_due_at.saturating_duration_since(now));
|
|
}
|
|
return;
|
|
}
|
|
|
|
if !self.thread_usage_is_selected() {
|
|
self.cancel_thread_usage_polling();
|
|
return;
|
|
}
|
|
|
|
if settlement_due {
|
|
self.thread_usage.settlement_refresh_due_at = None;
|
|
}
|
|
if retry_due {
|
|
self.thread_usage.retry_due_at = None;
|
|
}
|
|
self.request_thread_usage();
|
|
}
|
|
|
|
pub(super) fn request_thread_usage_for_status(&mut self, handle: StatusHistoryHandle) {
|
|
if !self.thread_usage_is_available() {
|
|
return;
|
|
}
|
|
|
|
let Some(thread_id) = self.thread_id else {
|
|
return;
|
|
};
|
|
if self.thread_usage.thread_id != Some(thread_id) {
|
|
self.clear_thread_usage_state();
|
|
self.thread_usage.thread_id = Some(thread_id);
|
|
}
|
|
|
|
self.thread_usage.status_history_handles.push(handle);
|
|
self.thread_usage.status_requested = true;
|
|
self.thread_usage.retry_attempts = 0;
|
|
self.request_thread_usage();
|
|
}
|
|
|
|
pub(super) fn cancel_thread_usage_polling(&mut self) {
|
|
if self.thread_usage.status_requested {
|
|
return;
|
|
}
|
|
|
|
self.thread_usage.pending_request_id = None;
|
|
self.thread_usage.requested = false;
|
|
self.thread_usage.retry_attempts = 0;
|
|
self.thread_usage.retry_due_at = None;
|
|
self.thread_usage.settlement_attempts = 0;
|
|
self.thread_usage.settlement_baseline_credits_micros = None;
|
|
self.thread_usage.settlement_baseline_usd_micros = None;
|
|
self.thread_usage.settlement_request_id = None;
|
|
self.thread_usage.settlement_refresh_due_at = None;
|
|
}
|
|
|
|
pub(crate) fn is_pending_thread_usage(&self, thread_id: ThreadId, request_id: Uuid) -> bool {
|
|
self.thread_id == Some(thread_id)
|
|
&& self.thread_usage.thread_id == Some(thread_id)
|
|
&& self.thread_usage.pending_request_id == Some(request_id)
|
|
}
|
|
|
|
pub(crate) fn finish_thread_usage_refresh(
|
|
&mut self,
|
|
thread_id: ThreadId,
|
|
request_id: Uuid,
|
|
result: Result<ThreadUsageOutcome, String>,
|
|
) -> bool {
|
|
if !self.is_pending_thread_usage(thread_id, request_id) {
|
|
return false;
|
|
}
|
|
|
|
self.thread_usage.pending_request_id = None;
|
|
let mut usage_updated = false;
|
|
self.thread_usage.status_requested = false;
|
|
let post_turn_request = self.thread_usage.settlement_request_id == Some(request_id);
|
|
match result {
|
|
Ok(ThreadUsageOutcome::Disabled) => {
|
|
self.thread_usage.feature_disabled = true;
|
|
self.thread_usage.estimate = None;
|
|
usage_updated = true;
|
|
self.thread_usage.retry_due_at = None;
|
|
self.thread_usage.settlement_refresh_due_at = None;
|
|
self.thread_usage.settlement_baseline_credits_micros = None;
|
|
self.thread_usage.settlement_baseline_usd_micros = None;
|
|
self.thread_usage.settlement_request_id = None;
|
|
}
|
|
Ok(ThreadUsageOutcome::Available(usage))
|
|
if usage.thread_id != thread_id.to_string() =>
|
|
{
|
|
tracing::warn!(
|
|
requested_thread_id = %thread_id,
|
|
returned_thread_id = %usage.thread_id,
|
|
"thread usage response referred to another thread"
|
|
);
|
|
self.schedule_thread_usage_retry();
|
|
}
|
|
Ok(ThreadUsageOutcome::Available(mut usage)) => {
|
|
usage_updated = true;
|
|
self.thread_usage.retry_attempts = 0;
|
|
self.thread_usage.retry_due_at = None;
|
|
let previous_positive_credits_micros = self
|
|
.thread_usage
|
|
.estimate
|
|
.as_ref()
|
|
.map(|estimate| estimate.estimated_usage_credits_micros)
|
|
.filter(|micros| *micros > 0);
|
|
let transient_zero_credits = usage.estimated_usage_credits_micros == 0
|
|
&& previous_positive_credits_micros.is_some();
|
|
if let Some(previous_positive_credits_micros) = previous_positive_credits_micros
|
|
&& transient_zero_credits
|
|
{
|
|
usage.estimated_usage_credits_micros = previous_positive_credits_micros;
|
|
}
|
|
let previous_positive_usd_micros = self
|
|
.thread_usage
|
|
.estimate
|
|
.as_ref()
|
|
.and_then(|estimate| estimate.estimated_usage_usd_micros)
|
|
.filter(|micros| *micros > 0);
|
|
let transient_zero_cost = usage.estimated_usage_usd_micros == Some(0)
|
|
&& previous_positive_usd_micros.is_some();
|
|
if let Some(previous_positive_usd_micros) = previous_positive_usd_micros
|
|
&& transient_zero_cost
|
|
{
|
|
usage.estimated_usage_usd_micros = Some(previous_positive_usd_micros);
|
|
}
|
|
if (transient_zero_credits || transient_zero_cost)
|
|
&& usage.groups.is_empty()
|
|
&& let Some(previous_usage) = self.thread_usage.estimate.as_ref()
|
|
{
|
|
usage.groups.clone_from(&previous_usage.groups);
|
|
}
|
|
let estimated_credits_micros = usage.estimated_usage_credits_micros;
|
|
let estimated_usd_micros = thread_cost_micros(&usage, self.plan_type);
|
|
self.thread_usage.estimate = Some(usage);
|
|
if let Some(baseline) = self.thread_usage.settlement_baseline_credits_micros {
|
|
if !post_turn_request {
|
|
self.thread_usage.settlement_baseline_credits_micros =
|
|
Some(baseline.max(estimated_credits_micros));
|
|
self.thread_usage.settlement_baseline_usd_micros = match (
|
|
self.thread_usage.settlement_baseline_usd_micros,
|
|
estimated_usd_micros,
|
|
) {
|
|
(Some(previous), Some(current)) => Some(previous.max(current)),
|
|
(previous, current) => previous.or(current),
|
|
};
|
|
} else {
|
|
let mut selected = self.selected_thread_usage();
|
|
if !self.thread_usage.status_history_handles.is_empty() {
|
|
selected.credits = self.plan_type != Some(PlanType::Ent26);
|
|
selected.estimated_cost |= self.plan_type == Some(PlanType::Ent26)
|
|
|| self.thread_usage.settlement_baseline_usd_micros.is_some()
|
|
|| estimated_usd_micros.is_some();
|
|
}
|
|
let credits_settled =
|
|
!selected.credits || estimated_credits_micros > baseline;
|
|
let cost_settled = !selected.estimated_cost
|
|
|| estimated_usd_micros.is_some_and(|current| {
|
|
self.thread_usage
|
|
.settlement_baseline_usd_micros
|
|
.map_or(current > 0, |previous| current > previous)
|
|
});
|
|
if credits_settled && cost_settled {
|
|
self.thread_usage.settlement_baseline_credits_micros = None;
|
|
self.thread_usage.settlement_baseline_usd_micros = None;
|
|
self.thread_usage.settlement_request_id = None;
|
|
self.thread_usage.settlement_refresh_due_at = None;
|
|
} else if self.thread_usage.settlement_refresh_due_at.is_none() {
|
|
self.schedule_next_thread_usage_settlement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
tracing::debug!(error = %err, "failed to fetch estimated thread usage");
|
|
self.schedule_thread_usage_retry();
|
|
}
|
|
}
|
|
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());
|
|
}
|
|
if self
|
|
.thread_usage
|
|
.settlement_baseline_credits_micros
|
|
.is_none()
|
|
{
|
|
self.thread_usage.status_history_handles.clear();
|
|
}
|
|
}
|
|
if self
|
|
.thread_usage
|
|
.settlement_baseline_credits_micros
|
|
.is_some()
|
|
&& self.thread_usage.settlement_request_id.is_none()
|
|
&& self.thread_usage_is_selected()
|
|
{
|
|
self.request_thread_usage();
|
|
}
|
|
self.refresh_status_line();
|
|
self.request_redraw();
|
|
true
|
|
}
|
|
|
|
pub(super) fn status_line_thread_credits_micros(&self) -> Option<i64> {
|
|
self.estimated_thread_usage()
|
|
.filter(|_| self.plan_type != Some(PlanType::Ent26))
|
|
.map(|usage| usage.estimated_usage_credits_micros)
|
|
}
|
|
|
|
pub(super) fn status_line_thread_cost_micros(&self) -> Option<i64> {
|
|
thread_cost_micros(self.estimated_thread_usage()?, self.plan_type)
|
|
}
|
|
|
|
pub(super) fn estimated_thread_usage(&self) -> Option<&ThreadUsage> {
|
|
self.thread_usage.estimate.as_ref()
|
|
}
|
|
|
|
fn request_thread_usage(&mut self) {
|
|
let Some(thread_id) = self.thread_id else {
|
|
return;
|
|
};
|
|
if !self.thread_usage_is_available() || self.thread_usage.pending_request_id.is_some() {
|
|
return;
|
|
}
|
|
|
|
let request_id = Uuid::new_v4();
|
|
self.thread_usage.pending_request_id = Some(request_id);
|
|
self.thread_usage.requested = true;
|
|
self.thread_usage.thread_id = Some(thread_id);
|
|
if self
|
|
.thread_usage
|
|
.settlement_baseline_credits_micros
|
|
.is_some()
|
|
{
|
|
self.thread_usage.settlement_request_id = Some(request_id);
|
|
}
|
|
self.app_event_tx.send(AppEvent::RefreshThreadUsage {
|
|
thread_id,
|
|
request_id,
|
|
});
|
|
}
|
|
|
|
pub(super) fn thread_usage_is_available(&self) -> bool {
|
|
self.has_codex_backend_auth
|
|
&& !self.thread_usage.feature_disabled
|
|
&& self.thread_id.is_some()
|
|
&& matches!(
|
|
self.plan_type,
|
|
Some(
|
|
PlanType::Ent26
|
|
| PlanType::Business
|
|
| PlanType::EnterpriseCbpUsageBased
|
|
| PlanType::EnterpriseCbpAutomation
|
|
)
|
|
)
|
|
}
|
|
|
|
fn thread_usage_is_selected(&self) -> bool {
|
|
let selected = self.selected_thread_usage();
|
|
selected.credits || selected.estimated_cost
|
|
}
|
|
|
|
fn selected_thread_usage(&self) -> SelectedThreadUsage {
|
|
let mut selected = SelectedThreadUsage::default();
|
|
for item in self.configured_status_line_items() {
|
|
match item.parse::<StatusLineItem>() {
|
|
Ok(StatusLineItem::ThreadCredits) => selected.credits = true,
|
|
Ok(StatusLineItem::EstimatedThreadCost) => selected.estimated_cost = true,
|
|
Ok(_) | Err(_) => {}
|
|
}
|
|
}
|
|
for item in self.configured_terminal_title_items() {
|
|
match item.parse::<TerminalTitleItem>() {
|
|
Ok(TerminalTitleItem::ThreadCredits) => selected.credits = true,
|
|
Ok(TerminalTitleItem::EstimatedThreadCost) => selected.estimated_cost = true,
|
|
Ok(_) | Err(_) => {}
|
|
}
|
|
}
|
|
selected.credits &= self.plan_type != Some(PlanType::Ent26);
|
|
selected
|
|
}
|
|
|
|
fn schedule_next_thread_usage_settlement(&mut self) {
|
|
let Some(delay) = THREAD_USAGE_SETTLEMENT_DELAYS
|
|
.get(self.thread_usage.settlement_attempts)
|
|
.copied()
|
|
else {
|
|
self.thread_usage.settlement_baseline_credits_micros = None;
|
|
self.thread_usage.settlement_baseline_usd_micros = None;
|
|
self.thread_usage.settlement_request_id = None;
|
|
return;
|
|
};
|
|
self.thread_usage.settlement_attempts += 1;
|
|
self.thread_usage.settlement_refresh_due_at = Some(Instant::now() + delay);
|
|
self.frame_requester.schedule_frame_in(delay);
|
|
}
|
|
|
|
fn schedule_thread_usage_retry(&mut self) {
|
|
if !self.thread_usage_is_selected() {
|
|
return;
|
|
}
|
|
|
|
let Some(delay) = THREAD_USAGE_RETRY_DELAYS
|
|
.get(self.thread_usage.retry_attempts)
|
|
.copied()
|
|
else {
|
|
return;
|
|
};
|
|
self.thread_usage.retry_attempts += 1;
|
|
self.thread_usage.retry_due_at = Some(Instant::now() + delay);
|
|
self.frame_requester.schedule_frame_in(delay);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "thread_usage_tests.rs"]
|
|
mod tests;
|