mirror of
https://github.com/openai/codex.git
synced 2026-11-18 23:02:23 +00:00
Show estimated thread usage in /status (#38281)
## What changed - Extend `account/usage/read` with an optional `threadId` request and a backward-compatible `threadUsage` response containing estimated credits, optional USD cost, and model, reasoning, speed, and token breakdowns. - Fetch thread usage for eligible Business and Enterprise plans when `/status` is opened, then update the rendered status card asynchronously. - Preserve terminal scrollback when replacing a visible status-card tail, and append a refreshed card when the original tail can no longer be updated. ## Testing - Add app-server coverage for authentication, canonical thread IDs, unavailable billing routes, and malformed IDs. - Add TUI coverage for usage formatting, stale responses, retries, history updates, terminal reflow, and scrollback preservation. GitOrigin-RevId: 49300914b3fba917c0f08e8595363e04e5ba6d37
This commit is contained in:
1 parent
27a98dde4d
commit
f1a1fce26a
55 files changed
+2903
-60
No files matched your search
@@ -1,5 +1,8 @@
|
||||
use super::*;
|
||||
use crate::chatwidget::ThreadUsageOutcome;
|
||||
use assert_matches::assert_matches;
|
||||
use codex_app_server_protocol::ThreadUsage;
|
||||
use codex_app_server_protocol::ThreadUsageBreakdownGroup;
|
||||
use codex_utils_path_uri::PathUri;
|
||||
|
||||
#[tokio::test]
|
||||
@@ -197,3 +200,417 @@ async fn account_update_rejects_stale_status_rate_limit_snapshots() {
|
||||
|
||||
assert!(chat.rate_limit_snapshots_by_limit_id.is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_renders_immediately_and_updates_first_card_without_status_line() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
let thread_id =
|
||||
ThreadId::from_string("019fc8ab-1fb2-7000-8000-000000000001").expect("valid thread id");
|
||||
chat.thread_id = Some(thread_id);
|
||||
chat.plan_type = Some(PlanType::Business);
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
|
||||
let first_cell = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => cell,
|
||||
event => panic!("expected immediate /status output, got {event:?}"),
|
||||
};
|
||||
let initial = lines_to_single_string(&first_cell.display_lines(/*width*/ 90));
|
||||
assert!(!initial.contains("Thread usage"));
|
||||
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage {
|
||||
thread_id: requested_thread_id,
|
||||
request_id,
|
||||
}) => {
|
||||
assert_eq!(requested_thread_id, thread_id);
|
||||
request_id
|
||||
}
|
||||
event => panic!("expected /status to request thread usage, got {event:?}"),
|
||||
};
|
||||
drain_insert_history(&mut rx);
|
||||
assert!(chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
estimated_usage_usd_micros: Some(1_820_000),
|
||||
groups: vec![
|
||||
ThreadUsageBreakdownGroup {
|
||||
model: Some("gpt-5.4".to_string()),
|
||||
reasoning_effort: Some("high".to_string()),
|
||||
speed: Some("fast".to_string()),
|
||||
estimated_usage_credits_micros: 40_000_000,
|
||||
net_new_input_tokens: Some(80),
|
||||
cached_input_tokens: Some(20),
|
||||
input_tokens: Some(100),
|
||||
output_tokens: Some(40),
|
||||
total_tokens: Some(140),
|
||||
},
|
||||
ThreadUsageBreakdownGroup {
|
||||
model: Some("gpt-5-mini".to_string()),
|
||||
reasoning_effort: Some("medium".to_string()),
|
||||
speed: Some("standard".to_string()),
|
||||
estimated_usage_credits_micros: 10_000_000,
|
||||
net_new_input_tokens: Some(15),
|
||||
cached_input_tokens: Some(5),
|
||||
input_tokens: Some(20),
|
||||
output_tokens: Some(10),
|
||||
total_tokens: Some(30),
|
||||
},
|
||||
],
|
||||
})),
|
||||
));
|
||||
|
||||
let settled = lines_to_single_string(&first_cell.display_lines(/*width*/ 90));
|
||||
assert!(settled.contains("50 credits · ~$1.82"));
|
||||
assert!(settled.contains("GPT-5.4 80%, GPT-5 Mini 20%"));
|
||||
assert!(drain_insert_history(&mut rx).is_empty());
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let cell = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => cell,
|
||||
event => panic!("expected /status output with cached thread usage, got {event:?}"),
|
||||
};
|
||||
let rendered =
|
||||
normalize_snapshot_paths(lines_to_single_string(&cell.display_lines(/*width*/ 90)));
|
||||
assert!(rendered.contains("50 credits · ~$1.82"));
|
||||
assert!(rendered.contains("GPT-5.4 80%, GPT-5 Mini 20%"));
|
||||
assert!(rendered.contains("Medium 20%, High 80%"));
|
||||
assert!(rendered.contains("Fast mode 80%, Standard 20%"));
|
||||
assert!(rendered.contains("120 input (25 cached) + 50 output"));
|
||||
assert!(
|
||||
rendered.find("Limits:") < rendered.find("Thread usage:"),
|
||||
"account limits should appear above the thread usage group: {rendered}"
|
||||
);
|
||||
let thread_usage = rendered
|
||||
.lines()
|
||||
.skip_while(|line| !line.contains("Thread usage:"))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
assert_chatwidget_snapshot!("status_command_estimated_thread_usage", thread_usage);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_omits_thread_usage_for_non_cbp_enterprise_plans() {
|
||||
for plan_type in [
|
||||
Some(PlanType::Enterprise),
|
||||
Some(PlanType::Ent26),
|
||||
Some(PlanType::Pro),
|
||||
Some(PlanType::Edu),
|
||||
Some(PlanType::SelfServeBusinessUsageBased),
|
||||
Some(PlanType::Unknown),
|
||||
None,
|
||||
] {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
chat.thread_id = Some(ThreadId::new());
|
||||
chat.plan_type = plan_type;
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
|
||||
let rendered = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => {
|
||||
lines_to_single_string(&cell.display_lines(/*width*/ 90))
|
||||
}
|
||||
event => panic!("expected immediate /status output, got {event:?}"),
|
||||
};
|
||||
assert!(!rendered.contains("Thread usage"));
|
||||
assert!(
|
||||
!std::iter::from_fn(|| rx.try_recv().ok())
|
||||
.any(|event| matches!(event, AppEvent::RefreshThreadUsage { .. })),
|
||||
"unsupported plan {plan_type:?} must not request thread usage",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_stays_visible_and_updates_after_thread_usage_retry() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
let thread_id = ThreadId::new();
|
||||
chat.thread_id = Some(thread_id);
|
||||
chat.plan_type = Some(PlanType::Business);
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let cell = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => cell,
|
||||
event => panic!("expected immediate /status output, got {event:?}"),
|
||||
};
|
||||
assert!(!lines_to_single_string(&cell.display_lines(/*width*/ 90)).contains("Thread usage"));
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected thread usage request, got {event:?}"),
|
||||
};
|
||||
while rx.try_recv().is_ok() {}
|
||||
assert!(chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Err("thread usage temporarily unavailable".to_string()),
|
||||
));
|
||||
assert!(drain_insert_history(&mut rx).is_empty());
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let retry_cell = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => cell,
|
||||
event => panic!("expected another immediate /status output, got {event:?}"),
|
||||
};
|
||||
let retry_request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected thread usage retry, got {event:?}"),
|
||||
};
|
||||
assert!(chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
retry_request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
estimated_usage_usd_micros: Some(1_820_000),
|
||||
groups: Vec::new(),
|
||||
})),
|
||||
));
|
||||
|
||||
for status_cell in [&cell, &retry_cell] {
|
||||
assert!(
|
||||
lines_to_single_string(&status_cell.display_lines(/*width*/ 90))
|
||||
.contains("50 credits · ~$1.82")
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_renders_credits_and_breakdowns_without_usd_estimate() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
let thread_id = ThreadId::new();
|
||||
chat.thread_id = Some(thread_id);
|
||||
chat.plan_type = Some(PlanType::Business);
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let first_cell = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => cell,
|
||||
event => panic!("expected immediate /status output, got {event:?}"),
|
||||
};
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected thread usage request, got {event:?}"),
|
||||
};
|
||||
drain_insert_history(&mut rx);
|
||||
assert!(chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
estimated_usage_usd_micros: None,
|
||||
groups: vec![ThreadUsageBreakdownGroup {
|
||||
model: Some("gpt-5.4".to_string()),
|
||||
reasoning_effort: Some("high".to_string()),
|
||||
speed: Some("fast".to_string()),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
net_new_input_tokens: Some(80),
|
||||
cached_input_tokens: Some(20),
|
||||
input_tokens: Some(100),
|
||||
output_tokens: Some(40),
|
||||
total_tokens: Some(140),
|
||||
}],
|
||||
})),
|
||||
));
|
||||
|
||||
let first_rendered = lines_to_single_string(&first_cell.display_lines(/*width*/ 90));
|
||||
assert!(first_rendered.contains("50 credits"));
|
||||
assert!(first_rendered.contains("GPT-5.4 100%"));
|
||||
assert!(!first_rendered.contains("~$"));
|
||||
drain_insert_history(&mut rx);
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let rendered = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => {
|
||||
lines_to_single_string(&cell.display_lines(/*width*/ 90))
|
||||
}
|
||||
event => panic!("expected cached credits-only /status output, got {event:?}"),
|
||||
};
|
||||
assert!(rendered.contains("50 credits"));
|
||||
assert!(rendered.contains("GPT-5.4 100%"));
|
||||
assert!(rendered.contains("High 100%"));
|
||||
assert!(rendered.contains("Fast mode 100%"));
|
||||
assert!(rendered.contains("100 input (20 cached) + 40 output"));
|
||||
assert!(!rendered.contains("~$"));
|
||||
let thread_usage = rendered
|
||||
.lines()
|
||||
.skip_while(|line| !line.contains("Thread usage:"))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
assert_chatwidget_snapshot!(
|
||||
"status_command_estimated_thread_usage_without_usd",
|
||||
thread_usage
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_drops_stale_usd_when_updated_usage_has_only_credits() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
let thread_id = ThreadId::new();
|
||||
chat.thread_id = Some(thread_id);
|
||||
chat.plan_type = Some(PlanType::Business);
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(_)));
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected initial thread usage request, got {event:?}"),
|
||||
};
|
||||
drain_insert_history(&mut rx);
|
||||
assert!(chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 40_000_000,
|
||||
estimated_usage_usd_micros: Some(1_820_000),
|
||||
groups: Vec::new(),
|
||||
})),
|
||||
));
|
||||
|
||||
drain_insert_history(&mut rx);
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let cached = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => {
|
||||
lines_to_single_string(&cell.display_lines(/*width*/ 90))
|
||||
}
|
||||
event => panic!("expected cached /status output, got {event:?}"),
|
||||
};
|
||||
assert!(cached.contains("40 credits · ~$1.82"));
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected refreshed thread usage request, got {event:?}"),
|
||||
};
|
||||
drain_insert_history(&mut rx);
|
||||
assert!(chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
estimated_usage_usd_micros: None,
|
||||
groups: Vec::new(),
|
||||
})),
|
||||
));
|
||||
|
||||
drain_insert_history(&mut rx);
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
let refreshed = match rx.try_recv() {
|
||||
Ok(AppEvent::InsertHistoryCell(cell)) => {
|
||||
lines_to_single_string(&cell.display_lines(/*width*/ 90))
|
||||
}
|
||||
event => panic!("expected credits-only /status output, got {event:?}"),
|
||||
};
|
||||
assert!(refreshed.contains("50 credits"));
|
||||
assert!(!refreshed.contains("~$1.82"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_requests_thread_usage_for_remote_connection_metadata() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
chat.thread_id = Some(ThreadId::new());
|
||||
chat.update_account_state(
|
||||
/*status_account_display*/ None,
|
||||
Some(PlanType::Business),
|
||||
/*has_chatgpt_account*/ false,
|
||||
/*has_codex_backend_auth*/ true,
|
||||
);
|
||||
chat.remote_connection = Some(crate::status::remote_connection::RemoteConnectionStatus {
|
||||
address: "wss://remote.example.com".to_string(),
|
||||
version: "v1.0.0".to_string(),
|
||||
});
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(_)));
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::RefreshThreadUsage { .. }));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_requests_thread_usage_with_backend_only_authentication() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
chat.thread_id = Some(ThreadId::new());
|
||||
chat.update_account_state(
|
||||
/*status_account_display*/ None,
|
||||
Some(PlanType::Business),
|
||||
/*has_chatgpt_account*/ false,
|
||||
/*has_codex_backend_auth*/ true,
|
||||
);
|
||||
assert!(!chat.has_chatgpt_account());
|
||||
assert!(chat.has_codex_backend_auth());
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(_)));
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::RefreshThreadUsage { .. }));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_remains_visible_when_account_changes_during_usage_refresh() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
let thread_id = ThreadId::new();
|
||||
chat.thread_id = Some(thread_id);
|
||||
chat.plan_type = Some(PlanType::Business);
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(_)));
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected thread usage request, got {event:?}"),
|
||||
};
|
||||
drain_insert_history(&mut rx);
|
||||
|
||||
chat.update_account_state(
|
||||
/*status_account_display*/ None, /*plan_type*/ None,
|
||||
/*has_chatgpt_account*/ false, /*has_codex_backend_auth*/ false,
|
||||
);
|
||||
|
||||
assert!(!chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
estimated_usage_usd_micros: Some(1_820_000),
|
||||
groups: Vec::new(),
|
||||
})),
|
||||
));
|
||||
assert!(drain_insert_history(&mut rx).is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn status_command_remains_visible_when_thread_changes_during_usage_refresh() {
|
||||
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
|
||||
set_chatgpt_auth(&mut chat);
|
||||
let thread_id = ThreadId::new();
|
||||
chat.thread_id = Some(thread_id);
|
||||
chat.plan_type = Some(PlanType::Business);
|
||||
|
||||
chat.dispatch_command(SlashCommand::Status);
|
||||
assert_matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(_)));
|
||||
let request_id = match rx.try_recv() {
|
||||
Ok(AppEvent::RefreshThreadUsage { request_id, .. }) => request_id,
|
||||
event => panic!("expected thread usage request, got {event:?}"),
|
||||
};
|
||||
drain_insert_history(&mut rx);
|
||||
|
||||
chat.thread_id = Some(ThreadId::new());
|
||||
chat.clear_thread_usage_state();
|
||||
|
||||
assert!(!chat.finish_thread_usage_refresh(
|
||||
thread_id,
|
||||
request_id,
|
||||
Ok(ThreadUsageOutcome::Available(ThreadUsage {
|
||||
thread_id: thread_id.to_string(),
|
||||
estimated_usage_credits_micros: 50_000_000,
|
||||
estimated_usage_usd_micros: Some(1_820_000),
|
||||
groups: Vec::new(),
|
||||
})),
|
||||
));
|
||||
assert!(drain_insert_history(&mut rx).is_empty());
|
||||
}
|
||||
Reference in new issue
Block a user