Add OpenAI Live Usage view and model limits

CHANGELOG.md

@@ -9,6 +9,8 @@
 
 ## [Windows] Unreleased
 
+- OpenAI API: each Admin refresh also reads the last hour of 1-minute usage from the Admin Usage API (input plus output tokens, cached input included, Batch API traffic kept out of limit headroom) and carries a Tokens/min grid with a reporting frontier, so buckets that arrive late show as pending instead of zero. The backend can also load 15-minute, 1-hour or 6-hour windows, read per-project rate-limit caps, and measure headroom against manual per-model organization limits stored in settings. The per-refresh request can be turned off, and a failure never affects the daily usage. The menu bar token comes in a later release (upstream #4495).
+- OpenAI API: the card shows the last-hour Tokens/min grid (latest, peak, 5-minute average, reporting frontier, and pending minutes drawn as outlines), and Settings > Providers > OpenAI adds a Live Usage section with a refresh switch, a per-model organization limits editor, a 15-minute / 1-hour / 6-hour window with per-model rows, and the organization caps list, which stays hidden when a project id is saved (upstream #4495).
 - Tray: add a **Progress bars stacked** menu bar style that draws the session and weekly meters as two equal-height rows on the single tray icon, with the same windows and pace tint as **Meter bars**; older settings files keep their style (upstream #4436).
 - Settings providers: show only enabled providers from the sidebar options menu, search by CLI alias (such as `openai` for Codex), restore the default provider order, and undo a drag reorder or a restore with Ctrl+Z or the options menu. Hidden providers keep their slots when the order changes (upstream #4440).
 - Add **Color by provider** to Settings > Menu Bar (off by default): tints the tray usage bars and percent text with the shown provider's brand or accent color, keeps pace colors and the error colors unchanged, and falls back to the usual colors when a tint would be hard to see on the tray background (upstream #4321).

apps/desktop-tauri/src-tauri/src/commands/bridge.rs

@@ -1,3 +1,6 @@
+mod openai_live;
+#[cfg(test)]
+mod openai_live_tests;
 mod openai_usage;
 #[cfg(test)]
 mod openai_usage_tests;
@@ -7,6 +10,7 @@ mod status;
 mod throughput;
 #[cfg(test)]
 mod throughput_tests;
+pub(crate) use openai_live::{ModelRateLimitSnapshot, OrgRateLimitsSnapshot};
 pub(crate) use openai_usage::OpenAiApiUsageSnapshot;
 pub use quota_block::MonthlyLimitBlockSnapshot;
 pub(crate) use status::{compact_tray_status_label, friendly_provider_error};
@@ -1061,6 +1065,12 @@ pub struct SettingsSnapshot {
     codex_external_oauth_sources_allowed: bool,
     codex_local_session_cost_ledger_enabled: bool,
     codex_openai_web_battery_saver_enabled: bool,
+    /// OpenAI API Live Usage (upstream #4495): fetch Tokens/min on each refresh.
+    #[serde(rename = "openAiLiveUsageEnabled")]
+    openai_live_usage_enabled: bool,
+    /// Manual per-model organization limits, read by the card's limit line and the editor.
+    #[serde(rename = "openAiModelRateLimits")]
+    openai_model_rate_limits: Vec<ModelRateLimitSnapshot>,
     disable_keychain_access: bool,
     wayfinder_gateway_url: String,
     provider_metrics: std::collections::HashMap<String, &'static str>,
@@ -1122,6 +1132,12 @@ impl From<Settings> for SettingsSnapshot {
         let claude_swap_enabled = settings.claude_swap_enabled();
         let claude_swap_executable_path = settings.claude_swap_executable_path().to_string();
         let codex_spark_usage_visible = settings.codex_spark_usage_visible();
+        let openai_live_usage_enabled = settings.live_usage_enabled(ProviderId::OpenAIApi);
+        let openai_model_rate_limits = settings
+            .model_rate_limits(ProviderId::OpenAIApi)
+            .iter()
+            .map(ModelRateLimitSnapshot::from)
+            .collect();
         let codex_openai_web_extras = settings.codex_openai_web_extras();
         let codex_historical_tracking = settings.codex_historical_tracking();
         let codex_local_session_cost_ledger_enabled =
@@ -1214,6 +1230,8 @@ impl From<Settings> for SettingsSnapshot {
             stay_awake_enabled: settings.stay_awake_enabled,
             agent_session_ssh_hosts: settings.agent_session_ssh_hosts,
             hooks_enabled: settings.hooks_enabled,
+            openai_live_usage_enabled,
+            openai_model_rate_limits,
             http_proxy_enabled: settings.http_proxy_enabled,
             http_proxy_url: settings.http_proxy_url,
             http_proxy_username: settings.http_proxy_username,

apps/desktop-tauri/src-tauri/src/commands/bridge/openai_live.rs

@@ -0,0 +1,68 @@
+//! Bridge DTOs for OpenAI Live Usage (upstream 0.75.0 #4495): the manual per-model
+//! organization limits the Settings editor and the card read, and the project caps the
+//! Live Usage window lists as context.
+//!
+//! Mirrors `ModelRateLimitSnapshot` and `OrgRateLimitsSnapshot` in `src/types/bridge.ts`.
+//! The Tokens/min window itself reuses `ProviderThroughputSnapshot`.
+
+use codexbar::providers::openaiapi::org_limits::OrgRateLimits;
+use codexbar::settings::ModelRateLimit;
+use serde::{Deserialize, Serialize};
+
+/// One manual organization limit, as stored in settings and sent by the editor.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ModelRateLimitSnapshot {
+    pub model: String,
+    pub tokens_per_minute: u64,
+    #[serde(default)]
+    pub requests_per_minute: Option<u64>,
+}
+
+impl From<&ModelRateLimit> for ModelRateLimitSnapshot {
+    fn from(limit: &ModelRateLimit) -> Self {
+        Self {
+            model: limit.model.clone(),
+            tokens_per_minute: limit.tokens_per_minute,
+            requests_per_minute: limit.requests_per_minute,
+        }
+    }
+}
+
+/// Project caps discovered across the organization, sorted by model ID.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrgRateLimitsSnapshot {
+    pub by_model: Vec<OrgModelRateLimitSnapshot>,
+    pub projects_sampled: usize,
+    pub truncated: bool,
+    /// Epoch seconds.
+    pub fetched_at: i64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrgModelRateLimitSnapshot {
+    pub model: String,
+    pub tokens_per_minute: u64,
+    pub requests_per_minute: Option<u64>,
+}
+
+impl From<&OrgRateLimits> for OrgRateLimitsSnapshot {
+    fn from(limits: &OrgRateLimits) -> Self {
+        Self {
+            by_model: limits
+                .by_model
+                .iter()
+                .map(|(model, limit)| OrgModelRateLimitSnapshot {
+                    model: model.clone(),
+                    tokens_per_minute: limit.tokens_per_minute,
+                    requests_per_minute: limit.requests_per_minute,
+                })
+                .collect(),
+            projects_sampled: limits.projects_sampled,
+            truncated: limits.truncated,
+            fetched_at: limits.fetched_at,
+        }
+    }
+}

apps/desktop-tauri/src-tauri/src/commands/bridge/openai_live_tests.rs

@@ -0,0 +1,66 @@
+use std::collections::BTreeMap;
+
+use codexbar::providers::openaiapi::org_limits::{OrgRateLimit, OrgRateLimits};
+use codexbar::settings::ModelRateLimit;
+
+use super::openai_live::{ModelRateLimitSnapshot, OrgRateLimitsSnapshot};
+
+#[test]
+fn model_rate_limit_snapshot_is_camel_case_with_null_rpm() {
+    let limit = ModelRateLimit::new("gpt-5", 40_000_000, None);
+    let json = serde_json::to_value(ModelRateLimitSnapshot::from(&limit)).unwrap();
+    assert_eq!(
+        json,
+        serde_json::json!({
+            "model": "gpt-5",
+            "tokensPerMinute": 40_000_000,
+            "requestsPerMinute": null,
+        })
+    );
+}
+
+#[test]
+fn model_rate_limit_snapshot_accepts_a_missing_rpm_from_the_editor() {
+    let snapshot: ModelRateLimitSnapshot =
+        serde_json::from_str(r#"{"model":"gpt-5","tokensPerMinute":1}"#).unwrap();
+    assert_eq!(snapshot.requests_per_minute, None);
+    assert_eq!(snapshot.tokens_per_minute, 1);
+}
+
+#[test]
+fn org_rate_limits_snapshot_lists_models_sorted_with_camel_case_fields() {
+    let mut by_model = BTreeMap::new();
+    by_model.insert(
+        "gpt-5-mini".to_string(),
+        OrgRateLimit {
+            tokens_per_minute: 2,
+            requests_per_minute: Some(3),
+        },
+    );
+    by_model.insert(
+        "gpt-4o".to_string(),
+        OrgRateLimit {
+            tokens_per_minute: 5,
+            requests_per_minute: None,
+        },
+    );
+    let limits = OrgRateLimits {
+        by_model,
+        projects_sampled: 2,
+        truncated: true,
+        fetched_at: 1_800,
+    };
+    let json = serde_json::to_value(OrgRateLimitsSnapshot::from(&limits)).unwrap();
+    assert_eq!(
+        json,
+        serde_json::json!({
+            "byModel": [
+                { "model": "gpt-4o", "tokensPerMinute": 5, "requestsPerMinute": null },
+                { "model": "gpt-5-mini", "tokensPerMinute": 2, "requestsPerMinute": 3 },
+            ],
+            "projectsSampled": 2,
+            "truncated": true,
+            "fetchedAt": 1_800,
+        })
+    );
+}

apps/desktop-tauri/src-tauri/src/commands/mod.rs

@@ -45,6 +45,7 @@ mod diagnostics;
 mod grok_accounts;
 mod hooks;
 mod locale_cmd;
+mod openai_live;
 mod preferences_transfer;
 mod provider_detail;
 mod provider_refresh;
@@ -70,6 +71,7 @@ pub use diagnostics::*;
 pub use grok_accounts::*;
 pub use hooks::*;
 pub use locale_cmd::*;
+pub use openai_live::*;
 pub use preferences_transfer::*;
 pub use provider_detail::*;
 #[cfg(test)]
@@ -88,6 +90,8 @@ mod credential_lane_tests;
 #[cfg(test)]
 mod last_good_owner_tests;
 #[cfg(test)]
+mod openai_live_tests;
+#[cfg(test)]
 mod session_cookie_scope_tests;
 #[cfg(test)]
 mod tests;

apps/desktop-tauri/src-tauri/src/commands/openai_live.rs

@@ -0,0 +1,151 @@
+//! OpenAI Live Usage commands (upstream 0.75.0 #4495): the on-demand Tokens/min window
+//! and the organization project caps, plus the validation for manual per-model limits.
+//!
+//! Both fetches resolve the stored Admin key and the saved project scope the same way the
+//! refresh path does. Errors are mapped to friendly text without the key or raw bodies.
+
+use std::collections::HashSet;
+
+use codexbar::providers::OpenAIApiProvider;
+use codexbar::providers::openaiapi::live::LiveUsageError;
+use codexbar::providers::openaiapi::org_limits::OrgRateLimitsError;
+use codexbar::settings::ModelRateLimit;
+
+use super::bridge::{ModelRateLimitSnapshot, OrgRateLimitsSnapshot, ProviderThroughputSnapshot};
+use super::*;
+
+/// Largest integer a JavaScript number holds exactly; the editor cannot send more.
+const MAX_RATE_LIMIT: u64 = 9_007_199_254_740_991;
+const MAX_MODEL_ID_LEN: usize = 200;
+
+/// Friendly, key-free text for a failed Live Usage window.
+pub(crate) fn live_usage_error_message(error: &LiveUsageError) -> String {
+    match error {
+        LiveUsageError::MissingCredential => {
+            "Add an OpenAI organization Admin API key in Settings > Providers > OpenAI to see live usage."
+                .to_string()
+        }
+        LiveUsageError::AdminKeyRequired => {
+            "Live usage needs an OpenAI organization Admin API key (sk-admin-...). Project and service-account keys cannot read organization usage."
+                .to_string()
+        }
+        LiveUsageError::RateLimited => {
+            "OpenAI live usage is rate limited. Try again in a minute.".to_string()
+        }
+        LiveUsageError::ApiFailure(code) => {
+            format!("OpenAI live usage API failed (HTTP {code}).")
+        }
+        LiveUsageError::ParseFailure => {
+            "Could not read the OpenAI live usage response.".to_string()
+        }
+        LiveUsageError::InvalidWindow => {
+            "OpenAI live usage supports 15-minute, 1-hour, and 6-hour windows.".to_string()
+        }
+        LiveUsageError::Network => "Could not reach the OpenAI live usage API.".to_string(),
+    }
+}
+
+/// Friendly, key-free text for a failed organization limits read.
+pub(crate) fn org_rate_limits_error_message(error: &OrgRateLimitsError) -> String {
+    match error {
+        OrgRateLimitsError::MissingCredential => {
+            "Add an OpenAI organization Admin API key to read project limits.".to_string()
+        }
+        OrgRateLimitsError::AdminKeyRequired => {
+            "Project limits need an OpenAI Admin API key with project read permissions.".to_string()
+        }
+        OrgRateLimitsError::RateLimited => {
+            "OpenAI project limits are temporarily rate limited. Try again in a minute.".to_string()
+        }
+        OrgRateLimitsError::ApiFailure(code) => {
+            format!("OpenAI project limits API failed (HTTP {code}).")
+        }
+        OrgRateLimitsError::ParseFailure => {
+            "Could not read the OpenAI project limits response.".to_string()
+        }
+        OrgRateLimitsError::Network => "Could not reach the OpenAI project limits API.".to_string(),
+    }
+}
+
+/// Validates the editor's rows before they replace the stored list. Unlike the settings
+/// loader, which silently drops malformed rows, a bad editor row is reported to the user.
+/// A zero requests-per-minute means "no RPM limit", as upstream.
+pub(crate) fn validated_model_rate_limits(
+    rows: &[ModelRateLimitSnapshot],
+) -> Result<Vec<ModelRateLimit>, String> {
+    let mut seen = HashSet::new();
+    let mut limits = Vec::with_capacity(rows.len());
+    for row in rows {
+        let model = row.model.trim();
+        if model.is_empty() {
+            return Err("Each rate limit needs a model ID.".to_string());
+        }
+        if model.chars().count() > MAX_MODEL_ID_LEN || model.chars().any(char::is_control) {
+            return Err(format!(
+                "Model IDs must be on one line and at most {MAX_MODEL_ID_LEN} characters."
+            ));
+        }
+        if !seen.insert(model) {
+            return Err(format!("Model {model} is listed more than once."));
+        }
+        if row.tokens_per_minute == 0 || row.tokens_per_minute > MAX_RATE_LIMIT {
+            return Err(format!(
+                "Tokens per minute for {model} must be between 1 and {MAX_RATE_LIMIT}."
+            ));
+        }
+        if row
+            .requests_per_minute
+            .is_some_and(|rpm| rpm > MAX_RATE_LIMIT)
+        {
+            return Err(format!(
+                "Requests per minute for {model} must be at most {MAX_RATE_LIMIT}."
+            ));
+        }
+        limits.push(ModelRateLimit::new(
+            model,
+            row.tokens_per_minute,
+            row.requests_per_minute.filter(|rpm| *rpm > 0),
+        ));
+    }
+    Ok(ModelRateLimit::validated(limits))
+}
+
+/// The saved OpenAI project scope, or `None` for the whole organization.
+pub(super) fn openai_project_scope(settings: &Settings) -> Option<String> {
+    let id = settings.workspace_id(ProviderId::OpenAIApi).trim();
+    (!id.is_empty()).then(|| id.to_string())
+}
+
+/// The stored Admin/API key, read the way the refresh path reads it. Never logged.
+fn stored_openai_api_key() -> Option<String> {
+    ApiKeys::load()
+        .get(ProviderId::OpenAIApi.cli_name())
+        .map(str::to_string)
+}
+
+/// Last-hour-or-longer Tokens/min window for the OpenAI API card's Live Usage view.
+/// `window_minutes` must be 15, 60 or 360.
+#[tauri::command]
+pub async fn get_openai_live_usage(
+    window_minutes: u32,
+) -> Result<ProviderThroughputSnapshot, String> {
+    let project_id = openai_project_scope(&Settings::load());
+    let key = stored_openai_api_key();
+    let usage = OpenAIApiProvider::new()
+        .fetch_live_usage(key.as_deref(), project_id.as_deref(), window_minutes)
+        .await
+        .map_err(|error| live_usage_error_message(&error))?;
+    Ok(ProviderThroughputSnapshot::from(&usage.throughput()))
+}
+
+/// Project caps across the organization, shown as context in the Live Usage view. The
+/// caller skips this when a project scope is saved.
+#[tauri::command]
+pub async fn get_openai_org_rate_limits() -> Result<OrgRateLimitsSnapshot, String> {
+    let key = stored_openai_api_key();
+    let limits = OpenAIApiProvider::new()
+        .fetch_org_rate_limits(key.as_deref())
+        .await
+        .map_err(|error| org_rate_limits_error_message(&error))?;
+    Ok(OrgRateLimitsSnapshot::from(&limits))
+}