Add spend control individual limit support

ssh4net · ssh4net · commit 8a7f94690149 · 2026-07-01T15:36:06.000+09:00
Parse and display `individualLimit` (spend control) data from the rate limits API response. Shows monthly usage as the primary card metric with rolling window limits as secondary lines. Adds `SpendControlLimitSnapshot` struct and formatting helpers for credit amounts.
diff --git a/src/codex_rpc/mod.rs b/src/codex_rpc/mod.rs
@@ -32,11 +32,20 @@ pub struct CreditsSnapshot {
     pub balance: Option<String>,
 }
 
+#[derive(Debug, Clone)]
+pub struct SpendControlLimitSnapshot {
+    pub limit: Option<String>,
+    pub remaining_percent: Option<f64>,
+    pub resets_at: Option<i64>,
+    pub used: Option<String>,
+}
+
 #[derive(Debug, Clone)]
 pub struct RateLimitSnapshot {
     pub limit_id: Option<String>,
     pub limit_name: Option<String>,
     pub plan_type: Option<String>,
+    pub individual_limit: Option<SpendControlLimitSnapshot>,
     pub primary: Option<RateLimitWindow>,
     pub secondary: Option<RateLimitWindow>,
     pub credits: Option<CreditsSnapshot>,
@@ -47,6 +56,7 @@ pub struct AccountRateLimits {
     pub limit_id: Option<String>,
     pub limit_name: Option<String>,
     pub plan_type: Option<String>,
+    pub individual_limit: Option<SpendControlLimitSnapshot>,
     pub primary: Option<RateLimitWindow>,
     pub secondary: Option<RateLimitWindow>,
     pub credits: Option<CreditsSnapshot>,
@@ -607,6 +617,7 @@ fn parse_rate_limits(value: &Value) -> Result<AccountRateLimits> {
         limit_id: snapshot.limit_id.clone(),
         limit_name: snapshot.limit_name.clone(),
         plan_type: snapshot.plan_type.clone(),
+        individual_limit: snapshot.individual_limit.clone(),
         primary: snapshot.primary.clone(),
         secondary: snapshot.secondary.clone(),
         credits: snapshot.credits.clone(),
@@ -621,6 +632,10 @@ fn parse_rate_limit_snapshot(value: &Value) -> Option<RateLimitSnapshot> {
     let limit_id = read_string(obj.get("limitId").or_else(|| obj.get("limit_id")));
     let limit_name = read_string(obj.get("limitName").or_else(|| obj.get("limit_name")));
     let plan_type = read_string(obj.get("planType").or_else(|| obj.get("plan_type")));
+    let individual_limit = obj
+        .get("individualLimit")
+        .or_else(|| obj.get("individual_limit"))
+        .and_then(parse_individual_limit);
     let primary = obj.get("primary").and_then(parse_window);
     let secondary = obj.get("secondary").and_then(parse_window);
 
@@ -651,12 +666,29 @@ fn parse_rate_limit_snapshot(value: &Value) -> Option<RateLimitSnapshot> {
         limit_id,
         limit_name,
         plan_type,
+        individual_limit,
         primary,
         secondary,
         credits,
     })
 }
 
+fn parse_individual_limit(value: &Value) -> Option<SpendControlLimitSnapshot> {
+    let obj = value.as_object()?;
+    Some(SpendControlLimitSnapshot {
+        limit: read_scalar_string(obj.get("limit")),
+        remaining_percent: obj
+            .get("remainingPercent")
+            .or_else(|| obj.get("remaining_percent"))
+            .and_then(as_f64),
+        resets_at: obj
+            .get("resetsAt")
+            .or_else(|| obj.get("resets_at"))
+            .and_then(as_i64_maybe_float),
+        used: read_scalar_string(obj.get("used")),
+    })
+}
+
 fn parse_window(value: &Value) -> Option<RateLimitWindow> {
     let obj = value.as_object()?;
     let used_percent = obj
@@ -685,6 +717,16 @@ fn read_string(value: Option<&Value>) -> Option<String> {
     (!value.is_empty()).then(|| value.to_string())
 }
 
+fn read_scalar_string(value: Option<&Value>) -> Option<String> {
+    let value = value?;
+    value
+        .as_str()
+        .map(|s| s.trim().to_string())
+        .or_else(|| value.as_i64().map(|n| n.to_string()))
+        .or_else(|| value.as_f64().map(|n| n.to_string()))
+        .filter(|s| !s.is_empty())
+}
+
 fn as_f64(value: &Value) -> Option<f64> {
     value
         .as_f64()
@@ -739,23 +781,38 @@ mod tests {
             "rateLimitResetCredits": { "availableCount": 2 },
             "rateLimits": {
                 "limitId": "codex",
-                "primary": { "usedPercent": 10, "windowDurationMins": 300 },
-                "secondary": { "usedPercent": 20, "windowDurationMins": 10080 }
+                "individualLimit": {
+                    "limit": "60000",
+                    "remainingPercent": 99,
+                    "resetsAt": 1785523200,
+                    "used": "564"
+                }
             },
             "rateLimitsByLimitId": {
                 "codex_extra": {
                     "limitName": "GPT-5.3-Codex-Spark",
-                    "primary": { "usedPercent": 30, "windowDurationMins": 300 }
+                    "primary": { "usedPercent": 30, "windowDurationMins": 300 },
+                    "secondary": { "usedPercent": 40, "windowDurationMins": 10080 }
                 },
                 "codex": {
-                    "primary": { "usedPercent": 10, "windowDurationMins": 300 }
+                    "individualLimit": {
+                        "limit": "60000",
+                        "remainingPercent": 99,
+                        "resetsAt": 1785523200,
+                        "used": "564"
+                    }
                 }
             }
         });
 
         let limits =
             parse_account_rate_limits_result(&v).expect("parse_account_rate_limits_result");
         assert_eq!(limits.limit_id.as_deref(), Some("codex"));
+        let individual_limit = limits.individual_limit.expect("individual limit");
+        assert_eq!(individual_limit.limit.as_deref(), Some("60000"));
+        assert_eq!(individual_limit.remaining_percent, Some(99.0));
+        assert_eq!(individual_limit.resets_at, Some(1785523200));
+        assert_eq!(individual_limit.used.as_deref(), Some("564"));
         assert_eq!(limits.reset_credits_available, Some(2));
         assert_eq!(limits.buckets.len(), 2);
         assert_eq!(limits.buckets[0].limit_id.as_deref(), Some("codex"));
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
@@ -2052,32 +2052,88 @@ fn format_limit_compact_line(
     format!("{label}{pct}{resets}")
 }
 
-fn format_limits_compact_lines(l: &crate::codex_rpc::AccountRateLimits) -> (String, String) {
-    let primary_label = l
-        .primary
-        .as_ref()
+fn format_rolling_limit_lines(
+    primary: Option<&crate::codex_rpc::RateLimitWindow>,
+    secondary: Option<&crate::codex_rpc::RateLimitWindow>,
+) -> (String, String) {
+    let primary_label = primary
         .and_then(|w| w.window_duration_mins)
         .and_then(format_window_label)
         .map(|w| format!("{w} limit:"))
         .unwrap_or_else(|| "5h limit:".to_string());
-    let l1 = format_limit_compact_line(&primary_label, l.primary.as_ref());
-    let l2 = format_limit_compact_line("Weekly:", l.secondary.as_ref());
+    let l1 = format_limit_compact_line(&primary_label, primary);
+    let l2 = format_limit_compact_line("Weekly:", secondary);
     (l1, l2)
 }
 
 fn format_limits_compact_card_lines(
     l: &crate::codex_rpc::AccountRateLimits,
 ) -> (String, Option<String>, Option<String>, Option<String>) {
-    let (primary, secondary) = format_limits_compact_lines(l);
-    let credits = format_credits_compact_line(l).unwrap_or_else(|| "Credits:  --".to_string());
+    let (rolling_primary, rolling_secondary) = rolling_windows_for_limits(l);
+    let (primary, secondary) = format_rolling_limit_lines(rolling_primary, rolling_secondary);
+    if let Some((monthly, used)) = format_individual_limit_compact_lines(l) {
+        return (monthly, Some(used), Some(primary), Some(secondary));
+    }
 
     if let Some(extra) = format_extra_bucket_compact_line(l) {
+        let credits = format_credits_compact_line(l).unwrap_or_else(|| "Credits:  --".to_string());
         (primary, Some(secondary), Some(extra), Some(credits))
     } else {
+        let credits = format_credits_compact_line(l).unwrap_or_else(|| "Credits:  --".to_string());
         (primary, Some(secondary), Some(credits), None)
     }
 }
 
+fn rolling_windows_for_limits(
+    l: &crate::codex_rpc::AccountRateLimits,
+) -> (
+    Option<&crate::codex_rpc::RateLimitWindow>,
+    Option<&crate::codex_rpc::RateLimitWindow>,
+) {
+    if l.primary.is_some() || l.secondary.is_some() {
+        return (l.primary.as_ref(), l.secondary.as_ref());
+    }
+    l.buckets
+        .iter()
+        .find(|bucket| bucket.primary.is_some() || bucket.secondary.is_some())
+        .map(|bucket| (bucket.primary.as_ref(), bucket.secondary.as_ref()))
+        .unwrap_or((None, None))
+}
+
+fn format_individual_limit_compact_lines(
+    l: &crate::codex_rpc::AccountRateLimits,
+) -> Option<(String, String)> {
+    let individual_limit = l.individual_limit.as_ref().or_else(|| {
+        l.buckets
+            .iter()
+            .find_map(|bucket| bucket.individual_limit.as_ref())
+    })?;
+
+    const LABEL_W: usize = 10;
+    let remaining = individual_limit
+        .remaining_percent
+        .filter(|v| v.is_finite())
+        .map(|v| format!("{}%", v.round() as i64))
+        .unwrap_or_else(|| "--%".to_string());
+    let resets = resets_label(individual_limit.resets_at)
+        .map(|s| format!(" ({s})"))
+        .unwrap_or_default();
+    let monthly = format!("{:<LABEL_W$}{remaining}{resets}", "Monthly:");
+
+    let used = individual_limit
+        .used
+        .as_deref()
+        .map(format_credit_amount)
+        .unwrap_or_else(|| "--".to_string());
+    let limit = individual_limit
+        .limit
+        .as_deref()
+        .map(format_credit_amount)
+        .unwrap_or_else(|| "--".to_string());
+    let used_line = format!("{:<LABEL_W$}{used}/{limit} used", "Credits:");
+    Some((monthly, used_line))
+}
+
 fn format_extra_bucket_compact_line(l: &crate::codex_rpc::AccountRateLimits) -> Option<String> {
     let active_id = l.limit_id.as_deref();
     let active_name = l.limit_name.as_deref();
@@ -2109,6 +2165,15 @@ fn compact_bucket_label(bucket: &crate::codex_rpc::RateLimitSnapshot) -> String
     format!("{}:", truncate_middle(cleaned, 9))
 }
 
+fn format_credit_amount(raw: &str) -> String {
+    let cleaned: String = raw.chars().filter(|c| !c.is_control()).collect();
+    let cleaned = cleaned.trim();
+    let number = cleaned.parse::<f64>().ok().filter(|v| v.is_finite());
+    number
+        .map(|v| format_count(v.round() as i64))
+        .unwrap_or_else(|| truncate_middle(cleaned, 12))
+}
+
 fn format_credits_compact_line(l: &crate::codex_rpc::AccountRateLimits) -> Option<String> {
     const LABEL_W: usize = 10;
     let credits = l.credits.as_ref()?;
@@ -2255,6 +2320,48 @@ mod tests {
         assert_eq!(truncate_middle("hello", 3), "...");
     }
 
+    #[test]
+    fn limits_card_uses_monthly_and_named_rolling_bucket() {
+        let limits = crate::codex_rpc::AccountRateLimits {
+            limit_id: Some("codex".to_string()),
+            limit_name: None,
+            plan_type: Some("enterprise".to_string()),
+            individual_limit: Some(crate::codex_rpc::SpendControlLimitSnapshot {
+                limit: Some("60000".to_string()),
+                remaining_percent: Some(99.0),
+                resets_at: None,
+                used: Some("564".to_string()),
+            }),
+            primary: None,
+            secondary: None,
+            credits: None,
+            buckets: vec![crate::codex_rpc::RateLimitSnapshot {
+                limit_id: Some("codex_bengalfox".to_string()),
+                limit_name: Some("GPT-5.3-Codex-Spark-Preview".to_string()),
+                plan_type: Some("enterprise".to_string()),
+                individual_limit: None,
+                primary: Some(crate::codex_rpc::RateLimitWindow {
+                    used_percent: Some(0.0),
+                    window_duration_mins: Some(300.0),
+                    resets_at: None,
+                }),
+                secondary: Some(crate::codex_rpc::RateLimitWindow {
+                    used_percent: Some(0.0),
+                    window_duration_mins: Some(10080.0),
+                    resets_at: None,
+                }),
+                credits: None,
+            }],
+            reset_credits_available: None,
+        };
+
+        let (value, caption1, caption2, caption3) = format_limits_compact_card_lines(&limits);
+        assert_eq!(value, "Monthly:  99%");
+        assert_eq!(caption1.as_deref(), Some("Credits:  564/60,000 used"));
+        assert_eq!(caption2.as_deref(), Some("5h limit: 100%"));
+        assert_eq!(caption3.as_deref(), Some("Weekly:   100%"));
+    }
+
     #[test]
     fn horizontal_tokens_show_total_and_out_of_cache() {
         let out =
