1use std::time::{Duration, SystemTime, UNIX_EPOCH};
25
26use super::retry::{hinted_wait, seconds};
27
28const NANOS: i128 = 1_000_000_000;
30
31const REQUESTS: [[&str; 3]; 4] = [
34 [
35 "x-ratelimit-limit-requests",
36 "x-ratelimit-remaining-requests",
37 "x-ratelimit-reset-requests",
38 ],
39 [
40 "anthropic-ratelimit-requests-limit",
41 "anthropic-ratelimit-requests-remaining",
42 "anthropic-ratelimit-requests-reset",
43 ],
44 [
45 "x-ratelimit-limit",
46 "x-ratelimit-remaining",
47 "x-ratelimit-reset",
48 ],
49 ["ratelimit-limit", "ratelimit-remaining", "ratelimit-reset"],
50];
51
52const TOKENS: [[&str; 3]; 3] = [
54 [
55 "x-ratelimit-limit-tokens",
56 "x-ratelimit-remaining-tokens",
57 "x-ratelimit-reset-tokens",
58 ],
59 [
60 "anthropic-ratelimit-tokens-limit",
61 "anthropic-ratelimit-tokens-remaining",
62 "anthropic-ratelimit-tokens-reset",
63 ],
64 [
65 "anthropic-ratelimit-input-tokens-limit",
66 "anthropic-ratelimit-input-tokens-remaining",
67 "anthropic-ratelimit-input-tokens-reset",
68 ],
69];
70
71#[derive(Debug, Clone, Copy, PartialEq, Eq)]
73pub struct Allowance {
74 pub limit: u64,
76 pub remaining: u64,
78 pub resets_in: Option<Duration>,
82}
83
84#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
86pub struct RateLimits {
87 pub requests: Option<Allowance>,
89 pub tokens: Option<Allowance>,
91}
92
93impl RateLimits {
94 pub fn from_headers(headers: &http::HeaderMap, now: SystemTime) -> Self {
104 Self {
105 requests: allowance(headers, &REQUESTS, now),
106 tokens: allowance(headers, &TOKENS, now),
107 }
108 }
109}
110
111fn allowance(headers: &http::HeaderMap, names: &[[&str; 3]], now: SystemTime) -> Option<Allowance> {
114 let text = |name: &str| headers.get(name)?.to_str().ok().map(str::trim);
115 names.iter().find_map(|[limit, remaining, reset]| {
116 Some(Allowance {
117 limit: leading_number(text(limit)?)?,
118 remaining: leading_number(text(remaining)?)?,
119 resets_in: text(reset).and_then(|reset| reset_in(reset, now)),
120 })
121 })
122}
123
124fn leading_number(text: &str) -> Option<u64> {
126 let end = text
127 .find(|c: char| !c.is_ascii_digit())
128 .unwrap_or(text.len());
129 text.get(..end)?.parse().ok()
130}
131
132fn reset_in(text: &str, now: SystemTime) -> Option<Duration> {
134 if plain_decimal(text).is_some() {
135 let number: f64 = text.parse().ok()?;
136 return if number > 1e12 {
138 unix_wait(text, 1_000_000, now)
139 } else if number > 1e9 {
140 unix_wait(text, NANOS, now)
141 } else {
142 seconds(number)
144 };
145 }
146 if let Some(wait) = hinted_wait(text) {
147 return Some(wait);
148 }
149 let at = match rfc3339(text) {
150 Some(at) => at,
151 None => since_epoch(httpdate::parse_http_date(text).ok()?)?,
152 };
153 until(at, now)
154}
155
156fn until(at: i128, now: SystemTime) -> Option<Duration> {
159 nanoseconds(at.checked_sub(since_epoch(now)?)?)
160}
161
162fn since_epoch(time: SystemTime) -> Option<i128> {
164 match time.duration_since(UNIX_EPOCH) {
165 Ok(after) => i128::try_from(after.as_nanos()).ok(),
166 Err(before) => i128::try_from(before.duration().as_nanos())
167 .ok()
168 .map(|n| -n),
169 }
170}
171
172pub(crate) fn rfc3339(text: &str) -> Option<i128> {
176 let (date, time) = text.split_once(['T', 't', ' '])?;
177 let mut date = date.split('-');
178 let year = digits(date.next()?, 4)?;
179 let month = digits(date.next()?, 2)?;
180 let day = digits(date.next()?, 2)?;
181 let (clock, offset) = match time.strip_suffix(['Z', 'z']) {
182 Some(clock) => (clock, 0),
183 None => {
184 let (clock, offset) = time.split_at_checked(time.rfind(['+', '-'])?)?;
185 let sign = if offset.starts_with('-') { -1 } else { 1 };
186 let (hours, minutes) = offset.get(1..)?.split_once(':')?;
187 let (hours, minutes) = (digits(hours, 2)?, digits(minutes, 2)?);
188 if hours > 23 || minutes > 59 {
189 return None;
190 }
191 (clock, sign * (hours * 3600 + minutes * 60))
192 }
193 };
194 let (clock, fraction) = clock.split_once('.').unwrap_or((clock, "0"));
195 if fraction.is_empty() || !fraction.bytes().all(|b| b.is_ascii_digit()) {
196 return None;
197 }
198 let fraction: i128 = format!("{:0<9}", fraction.get(..9).unwrap_or(fraction))
200 .parse()
201 .ok()?;
202 let mut clock = clock.split(':');
203 let hour = digits(clock.next()?, 2)?;
204 let minute = digits(clock.next()?, 2)?;
205 let second = digits(clock.next()?, 2)?;
206 let days = days_since_epoch(year, month, day)?;
207 let valid = date.next().is_none() && clock.next().is_none();
208 if !valid || hour > 23 || minute > 59 || second > 60 {
209 return None;
210 }
211 let seconds = days * 86_400 + hour * 3600 + minute * 60 + second - offset;
212 i128::from(seconds)
213 .checked_mul(NANOS)?
214 .checked_add(fraction)
215}
216
217fn unix_wait(text: &str, unit: i128, now: SystemTime) -> Option<Duration> {
222 let (whole, fraction, places) = plain_decimal(text)?;
223 let whole = whole.checked_mul(unit)?.checked_sub(since_epoch(now)?)?;
224 let scale = 10_i128.checked_pow(places)?;
225 let fraction = fraction.checked_mul(unit)?;
226 let left = whole.checked_add(fraction.div_euclid(scale))?;
227 let twice = fraction.rem_euclid(scale).checked_mul(2)?;
228 let up = twice > scale || (twice == scale && left.rem_euclid(2) == 1);
229 nanoseconds(left.checked_add(i128::from(up))?)
230}
231
232fn plain_decimal(text: &str) -> Option<(i128, i128, u32)> {
237 let (whole, fraction) = text.split_once('.').unwrap_or((text, ""));
238 let digits = |part: &str| part.bytes().all(|b| b.is_ascii_digit());
239 if whole.len() + fraction.len() == 0 || !digits(whole) || !digits(fraction) {
240 return None;
241 }
242 let fraction = fraction.get(..18).unwrap_or(fraction);
243 Some((
244 format!("0{whole}").parse().ok()?,
245 format!("0{fraction}").parse().ok()?,
246 u32::try_from(fraction.len()).ok()?,
247 ))
248}
249
250fn nanoseconds(nanos: i128) -> Option<Duration> {
252 let nanos = nanos.max(0);
253 let secs = u64::try_from(nanos / NANOS).ok()?;
254 Some(Duration::new(secs, u32::try_from(nanos % NANOS).ok()?))
255}
256
257fn digits(text: &str, width: usize) -> Option<i64> {
259 let ascii = text.len() == width && text.bytes().all(|b| b.is_ascii_digit());
260 ascii.then(|| text.parse().ok())?
261}
262
263fn days_since_epoch(year: i64, month: i64, day: i64) -> Option<i64> {
266 let days = |year: i64, month: i64, day: i64| {
267 let year = if month <= 2 { year - 1 } else { year };
268 let era = year.div_euclid(400);
269 let of_era = year - era * 400;
270 let of_year = (153 * ((month + 9) % 12) + 2) / 5 + day - 1;
271 era * 146_097 + of_era * 365 + of_era / 4 - of_era / 100 + of_year - 719_468
272 };
273 let (next_year, next_month) = if month == 12 {
274 (year + 1, 1)
275 } else {
276 (year, month + 1)
277 };
278 let length = days(next_year, next_month, 1) - days(year, month, 1);
279 ((1..=12).contains(&month) && (1..=length).contains(&day)).then(|| days(year, month, day))
280}
281
282#[cfg(test)]
283mod tests;