1use std::collections::HashMap;
2use std::path::PathBuf;
3use std::time::SystemTime;
4
5#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
6pub struct RateLimitState {
7 pub reset_at: f64,
8 pub recorded_at: f64,
9 pub reset_seconds: f64,
10}
11
12#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
13pub struct BucketState {
14 pub limit: Option<i64>,
15 pub remaining: Option<i64>,
16 pub reset_seconds: Option<f64>,
17 pub remaining_seconds_now: Option<f64>,
18}
19
20#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
21pub struct RateLimitTrackerState {
22 pub requests_min: Option<BucketState>,
23 pub requests_hour: Option<BucketState>,
24 pub tokens_min: Option<BucketState>,
25 pub tokens_hour: Option<BucketState>,
26}
27
28pub struct RateLimitGuard {
29 pub state_file_path: PathBuf,
30}
31
32fn get_now_secs() -> f64 {
33 SystemTime::now()
34 .duration_since(SystemTime::UNIX_EPOCH)
35 .map(|d| d.as_secs_f64())
36 .unwrap_or(0.0)
37}
38
39impl RateLimitGuard {
40 pub const MIN_RESET_FOR_BREAKER_SECONDS: f64 = 60.0;
41
42 pub fn new(state_file_path: Option<PathBuf>) -> Self {
43 let path = state_file_path.unwrap_or_else(|| {
44 let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
45 let mut p = PathBuf::from(home);
46 p.push(".rate_limits");
47 p.push("default.json");
48 p
49 });
50 Self { state_file_path: path }
51 }
52
53 pub fn get_remaining_cooldown(&self) -> Option<f64> {
54 if !self.state_file_path.exists() {
55 return None;
56 }
57 let raw = std::fs::read_to_string(&self.state_file_path).ok()?;
58 let state: RateLimitState = serde_json::from_str(&raw).ok()?;
59 let now = get_now_secs();
60 let remaining = state.reset_at - now;
61 if remaining > 0.0 {
62 return Some(remaining);
63 }
64 let _ = std::fs::remove_file(&self.state_file_path);
65 None
66 }
67
68 pub fn record_limit(
69 &self,
70 headers: Option<&HashMap<String, String>>,
71 error_context: Option<&serde_json::Value>,
72 default_cooldown_seconds: Option<f64>,
73 ) {
74 let now = get_now_secs();
75 let mut reset_at = None;
76
77 if let Some(header_sec) = self.parse_reset_seconds(headers) {
78 reset_at = Some(now + header_sec);
79 }
80
81 if reset_at.is_none() {
82 if let Some(ctx) = error_context {
83 if let Some(ctx_reset) = ctx.get("reset_at").and_then(|v| v.as_f64()) {
84 if ctx_reset > now {
85 reset_at = Some(ctx_reset);
86 }
87 }
88 }
89 }
90
91 let reset_at_val = reset_at.unwrap_or_else(|| {
92 now + default_cooldown_seconds.unwrap_or(300.0)
93 });
94
95 let state = RateLimitState {
96 reset_at: reset_at_val,
97 recorded_at: now,
98 reset_seconds: reset_at_val - now,
99 };
100
101 if let Some(parent) = self.state_file_path.parent() {
102 let _ = std::fs::create_dir_all(parent);
103 }
104
105 let random_suffix: String = SystemTime::now()
106 .duration_since(SystemTime::UNIX_EPOCH)
107 .map(|d| d.as_nanos())
108 .unwrap_or(0)
109 .to_string();
110 let tmp_path = self.state_file_path.with_extension(format!("tmp{}", random_suffix));
111
112 if let Ok(serialized) = serde_json::to_string(&state) {
113 if std::fs::write(&tmp_path, serialized).is_ok() {
114 let _ = std::fs::rename(&tmp_path, &self.state_file_path);
115 }
116 }
117 }
118
119 pub fn clear(&self) {
120 if self.state_file_path.exists() {
121 let _ = std::fs::remove_file(&self.state_file_path);
122 }
123 }
124
125 pub fn is_genuine_limit(
126 &self,
127 headers: Option<&HashMap<String, String>>,
128 last_known_state: Option<&RateLimitTrackerState>,
129 ) -> bool {
130 let buckets = self.parse_buckets_from_headers(headers);
131 if self.has_exhausted_bucket(&buckets) {
132 return true;
133 }
134 if let Some(state) = last_known_state {
135 if self.has_exhausted_bucket_in_state(state) {
136 return true;
137 }
138 }
139 false
140 }
141
142 fn parse_reset_seconds(&self, headers: Option<&HashMap<String, String>>) -> Option<f64> {
143 let hdrs = headers?;
144 let keys = [
145 "x-ratelimit-reset-requests-1h",
146 "x-ratelimit-reset-requests",
147 "retry-after",
148 ];
149 for key in &keys {
150 for (k, v) in hdrs {
151 if k.to_ascii_lowercase() == *key {
152 if let Ok(parsed) = v.parse::<f64>() {
153 if parsed > 0.0 {
154 return Some(parsed);
155 }
156 }
157 }
158 }
159 }
160 None
161 }
162
163 fn parse_buckets_from_headers(
164 &self,
165 headers: Option<&HashMap<String, String>>,
166 ) -> HashMap<String, (Option<i64>, Option<f64>)> {
167 let mut result = HashMap::new();
168 let hdrs = match headers {
169 None => return result,
170 Some(h) => h,
171 };
172
173 let tags = ["requests", "requests-1h", "tokens", "tokens-1h"];
174 for tag in &tags {
175 let rem_key = format!("x-ratelimit-remaining-{}", tag);
176 let res_key = format!("x-ratelimit-reset-{}", tag);
177
178 let mut remaining = None;
179 let mut reset = None;
180
181 for (k, v) in hdrs {
182 let k_lower = k.to_ascii_lowercase();
183 if k_lower == rem_key {
184 remaining = v.parse::<i64>().ok();
185 } else if k_lower == res_key {
186 reset = v.parse::<f64>().ok();
187 }
188 }
189
190 if remaining.is_some() || reset.is_some() {
191 result.insert(tag.to_string(), (remaining, reset));
192 }
193 }
194 result
195 }
196
197 fn has_exhausted_bucket(&self, buckets: &HashMap<String, (Option<i64>, Option<f64>)>) -> bool {
198 for (remaining, reset) in buckets.values() {
199 if let Some(rem) = remaining {
200 if *rem > 0 {
201 continue;
202 }
203 }
204 if let Some(res) = reset {
205 if *res >= Self::MIN_RESET_FOR_BREAKER_SECONDS {
206 return true;
207 }
208 }
209 }
210 false
211 }
212
213 fn has_exhausted_bucket_in_state(&self, state: &RateLimitTrackerState) -> bool {
214 let buckets = [
215 &state.requests_min,
216 &state.requests_hour,
217 &state.tokens_min,
218 &state.tokens_hour,
219 ];
220 for bucket in buckets.iter().copied().flatten() {
221 let limit = bucket.limit.unwrap_or(0);
222 let remaining = bucket.remaining.unwrap_or(0);
223 let reset = bucket.remaining_seconds_now
224 .or(bucket.reset_seconds)
225 .unwrap_or(0.0);
226
227 if limit <= 0 {
228 continue;
229 }
230 if remaining > 0 {
231 continue;
232 }
233 if reset >= Self::MIN_RESET_FOR_BREAKER_SECONDS {
234 return true;
235 }
236 }
237 false
238 }
239}
240
241pub fn format_remaining(seconds: f64) -> String {
242 let s = seconds.max(0.0).floor() as u64;
243 if s < 60 {
244 format!("{}s", s)
245 } else if s < 3600 {
246 let m = s / 60;
247 let sec = s % 60;
248 if sec > 0 {
249 format!("{}m {}s", m, sec)
250 } else {
251 format!("{}m", m)
252 }
253 } else {
254 let h = s / 3600;
255 let remainder = s % 3600;
256 let m = remainder / 60;
257 if m > 0 {
258 format!("{}h {}m", h, m)
259 } else {
260 format!("{}h", h)
261 }
262 }
263}