@vymalo/opencode-ratelimit 0.12.0 → 0.14.0

package/dist/plugin.js

@@ -1,461 +1,480 @@
 import { parseRateLimitOptions, selectTier } from "./config.js";
 import { parseRateLimit } from "./headers.js";
 /** Fallback backoff when a 429 carries no `x-ratelimit-reset` and no `Retry-After`. */
-export const DEFAULT_BACKOFF_MS = 1000;
+export const DEFAULT_BACKOFF_MS = 1e3;
 export function createProviderState() {
-    return { cooldownUntilMs: 0, cooldownMaxWaitMs: 0 };
+	return {
+		cooldownUntilMs: 0,
+		cooldownMaxWaitMs: 0
+	};
 }
 /**
- * Walk every provider in the assembled OpenCode config; for each one that has
- * opted in via `options.meta.rateLimit`, wrap its `options.fetch` with a
- * rate-limit-aware fetch. Synchronous — all real work happens lazily inside the
- * wrapper at request time.
- */
+* Walk every provider in the assembled OpenCode config; for each one that has
+* opted in via `options.meta.rateLimit`, wrap its `options.fetch` with a
+* rate-limit-aware fetch. Synchronous — all real work happens lazily inside the
+* wrapper at request time.
+*/
 export function installRateLimiter(input, deps) {
-    const providers = input.provider;
-    deps.logger.trace("ratelimit_install_start", {
-        providerCount: providers ? Object.keys(providers).length : 0
-    });
-    if (!providers) {
-        deps.logger.info("ratelimit_plugin_initialized", { providerCount: 0 });
-        return;
-    }
-    let enabledCount = 0;
-    for (const [providerId, providerConfig] of Object.entries(providers)) {
-        if (!providerConfig) {
-            continue;
-        }
-        deps.logger.trace("ratelimit_provider_optin_check", {
-            providerId,
-            hasOptions: Boolean(providerConfig.options)
-        });
-        const opts = parseRateLimitOptions(providerConfig.options);
-        if (!opts) {
-            deps.logger.debug("ratelimit_provider_skipped", { providerId, reason: "not_opted_in" });
-            continue;
-        }
-        deps.logger.trace("ratelimit_provider_optin_resolved", {
-            providerId,
-            scope: opts.scope,
-            headerPrefix: opts.headerPrefix,
-            tiers: opts.tiers.length
-        });
-        const options = (providerConfig.options ??= {});
-        // Compose with any fetch a prior plugin already installed (capture it now,
-        // not at call time, so we delegate to the original — not to ourselves).
-        const delegate = typeof options.fetch === "function" ? options.fetch : undefined;
-        deps.logger.trace("ratelimit_fetch_wrapped", {
-            providerId,
-            composedWithExistingFetch: Boolean(delegate)
-        });
-        const store = new Map();
-        options.fetch = makeRateLimitFetch(providerId, opts, store, deps, delegate);
-        enabledCount += 1;
-        deps.logger.info("ratelimit_provider_enabled", {
-            providerId,
-            scope: opts.scope,
-            tiers: opts.tiers.length,
-            headerPrefix: opts.headerPrefix
-        });
-    }
-    deps.logger.info("ratelimit_plugin_initialized", { providerCount: enabledCount });
+	const providers = input.provider;
+	deps.logger.trace("ratelimit_install_start", { providerCount: providers ? Object.keys(providers).length : 0 });
+	if (!providers) {
+		deps.logger.info("ratelimit_plugin_initialized", { providerCount: 0 });
+		return;
+	}
+	let enabledCount = 0;
+	for (const [providerId, providerConfig] of Object.entries(providers)) {
+		if (!providerConfig) {
+			continue;
+		}
+		deps.logger.trace("ratelimit_provider_optin_check", {
+			providerId,
+			hasOptions: Boolean(providerConfig.options)
+		});
+		const opts = parseRateLimitOptions(providerConfig.options);
+		if (!opts) {
+			deps.logger.debug("ratelimit_provider_skipped", {
+				providerId,
+				reason: "not_opted_in"
+			});
+			continue;
+		}
+		deps.logger.trace("ratelimit_provider_optin_resolved", {
+			providerId,
+			scope: opts.scope,
+			headerPrefix: opts.headerPrefix,
+			tiers: opts.tiers.length
+		});
+		const options = providerConfig.options ??= {};
+		// Compose with any fetch a prior plugin already installed (capture it now,
+		// not at call time, so we delegate to the original — not to ourselves).
+		const delegate = typeof options.fetch === "function" ? options.fetch : undefined;
+		deps.logger.trace("ratelimit_fetch_wrapped", {
+			providerId,
+			composedWithExistingFetch: Boolean(delegate)
+		});
+		const store = new Map();
+		options.fetch = makeRateLimitFetch(providerId, opts, store, deps, delegate);
+		enabledCount += 1;
+		deps.logger.info("ratelimit_provider_enabled", {
+			providerId,
+			scope: opts.scope,
+			tiers: opts.tiers.length,
+			headerPrefix: opts.headerPrefix
+		});
+	}
+	deps.logger.info("ratelimit_plugin_initialized", { providerCount: enabledCount });
 }
 /**
- * Build the fetch wrapper for one provider. The wrapper:
- *  1. Resolves the bucket (provider, or `(provider, model)` under `scope: "model"`).
- *  2. Pre-request gate: if that bucket's cooldown is armed, waits until it clears.
- *  3. Sends the request via the underlying fetch.
- *  4. Reads the rate-limit headers; selects the policy tier by reset magnitude.
- *     On `remaining: 0` it arms the gate for the next callers (only when the
- *     matched tier is `"wait"`).
- *  5. On a 429: a `"wait"` tier waits the reset window and retries (up to the
- *     tier's `maxRetries`); an `"error"` tier surfaces the 429 immediately.
- *
- * The Response is returned untouched (no `.clone()`) — we only read `status`
- * and `headers`, so the body stream is delivered to OpenCode intact.
- */
+* Build the fetch wrapper for one provider. The wrapper:
+*  1. Resolves the bucket (provider, or `(provider, model)` under `scope: "model"`).
+*  2. Pre-request gate: if that bucket's cooldown is armed, waits until it clears.
+*  3. Sends the request via the underlying fetch.
+*  4. Reads the rate-limit headers; selects the policy tier by reset magnitude.
+*     On `remaining: 0` it arms the gate for the next callers (only when the
+*     matched tier is `"wait"`).
+*  5. On a 429: a `"wait"` tier waits the reset window and retries (up to the
+*     tier's `maxRetries`); an `"error"` tier surfaces the 429 immediately.
+*
+* The Response is returned untouched (no `.clone()`) — we only read `status`
+* and `headers`, so the body stream is delivered to OpenCode intact.
+*/
 export function makeRateLimitFetch(providerId, opts, store, deps, delegate) {
-    const now = deps.now ?? Date.now;
-    const sleep = deps.sleep ?? defaultSleep;
-    const underlying = delegate ?? deps.fetchImpl ?? globalThis.fetch;
-    const { logger } = deps;
-    const isRequest = (value) => typeof Request !== "undefined" && value instanceof Request;
-    const wrapped = async (input, init) => {
-        // Honor an abort signal whether it rides on `init` or on a `Request` input.
-        const signal = init?.signal ?? (isRequest(input) ? input.signal : undefined) ?? undefined;
-        const model = opts.scope === "model" ? await modelFromRequest(input, init) : undefined;
-        if (opts.scope === "model") {
-            logger.trace("ratelimit_model_resolved", { providerId, model, matched: model !== undefined });
-        }
-        const key = model ? `${providerId}\u0000${model}` : providerId;
-        let state = store.get(key);
-        const bucketExisted = state !== undefined;
-        if (!state) {
-            state = createProviderState();
-            store.set(key, state);
-        }
-        logger.trace("ratelimit_fetch_invoked", {
-            providerId,
-            scope: opts.scope,
-            model,
-            bucketKey: key,
-            bucketExisted,
-            cooldownUntilMs: state.cooldownUntilMs
-        });
-        // 2. Pre-request gate — wait out a cooldown a previous "wait" tier armed.
-        if (state.cooldownUntilMs > now()) {
-            const waitMs = clampWait(state.cooldownUntilMs - now(), state.cooldownMaxWaitMs);
-            logger.trace("ratelimit_cooldown_gate_armed", {
-                providerId,
-                model,
-                cooldownUntilMs: state.cooldownUntilMs,
-                remainingMs: state.cooldownUntilMs - now(),
-                clampedWaitMs: waitMs,
-                maxWaitMs: state.cooldownMaxWaitMs
-            });
-            if (waitMs > 0) {
-                logger.info("ratelimit_throttle_wait", { providerId, model, waitMs });
-                await waitGate(state, sleep, now, state.cooldownMaxWaitMs, signal, logger, providerId, model, "pre_request");
-            }
-        }
-        // 3-5. Attempt loop.
-        let attempt = 0;
-        for (;;) {
-            // A Request body is single-use; send a fresh clone each attempt so a
-            // wait-tier retry doesn't fail with "body already used". (The original is
-            // never sent directly, so each clone has an unconsumed body.)
-            const attemptInput = isRequest(input) ? input.clone() : input;
-            logger.trace("ratelimit_underlying_fetch", { providerId, model, attempt });
-            const response = await underlying(attemptInput, init);
-            const snapshot = readSnapshot(response, opts, now(), logger, providerId);
-            logger.trace("ratelimit_snapshot_parsed", {
-                providerId,
-                model,
-                status: response.status,
-                limit: snapshot.limit,
-                remaining: snapshot.remaining,
-                resetSeconds: snapshot.resetSeconds,
-                resetAtMs: snapshot.resetAtMs,
-                retryAfterMs: snapshot.retryAfterMs
-            });
-            logger.debug("ratelimit_quota", {
-                providerId,
-                model,
-                remaining: snapshot.remaining,
-                limit: snapshot.limit,
-                resetSeconds: snapshot.resetSeconds
-            });
-            if (response.status !== 429) {
-                // Arm the gate for the NEXT callers when the window is exhausted — but
-                // only under a "wait" tier. An "error" tier wants the next request to
-                // hit a real 429 and be surfaced, so we leave the gate unarmed.
-                if (snapshot.remaining !== undefined &&
-                    snapshot.remaining <= 0 &&
-                    snapshot.resetAtMs !== undefined) {
-                    const resetForTier = effectiveResetSeconds(snapshot);
-                    const tier = selectTier(opts.tiers, resetForTier);
-                    logger.trace("ratelimit_exhausted_tier_selected", {
-                        providerId,
-                        model,
-                        resetSeconds: resetForTier,
-                        maxResetSeconds: tier.maxResetSeconds,
-                        action: tier.action,
-                        maxWaitMs: tier.maxWaitMs,
-                        maxRetries: tier.maxRetries
-                    });
-                    if (tier.action === "wait") {
-                        state.cooldownUntilMs = snapshot.resetAtMs;
-                        state.cooldownMaxWaitMs = tier.maxWaitMs;
-                        logger.trace("ratelimit_cooldown_set", {
-                            providerId,
-                            model,
-                            cooldownUntilMs: state.cooldownUntilMs,
-                            maxWaitMs: tier.maxWaitMs,
-                            source: "exhausted"
-                        });
-                    }
-                    else {
-                        // Error tier → don't arm, and drop any stale cooldown a prior
-                        // "wait" window left so the next request hits a real 429 at once.
-                        state.cooldownUntilMs = 0;
-                        state.cooldownMaxWaitMs = 0;
-                        logger.trace("ratelimit_cooldown_cleared", {
-                            providerId,
-                            model,
-                            source: "exhausted_error_tier"
-                        });
-                    }
-                }
-                return response;
-            }
-            const resetForTier = effectiveResetSeconds(snapshot);
-            const tier = selectTier(opts.tiers, resetForTier);
-            logger.trace("ratelimit_429_tier_selected", {
-                providerId,
-                model,
-                attempt,
-                resetSeconds: resetForTier,
-                maxResetSeconds: tier.maxResetSeconds,
-                action: tier.action,
-                maxWaitMs: tier.maxWaitMs,
-                maxRetries: tier.maxRetries
-            });
-            if (tier.action === "error") {
-                // Drop any cooldown a prior "wait" tier armed, so the fail-fast is
-                // actually fast — later requests must not sleep a stale window first.
-                state.cooldownUntilMs = 0;
-                state.cooldownMaxWaitMs = 0;
-                logger.trace("ratelimit_cooldown_cleared", {
-                    providerId,
-                    model,
-                    source: "429_error_tier"
-                });
-                logger.warn("ratelimit_failfast", {
-                    providerId,
-                    model,
-                    resetSeconds: snapshot.resetSeconds
-                });
-                return response;
-            }
-            if (attempt >= tier.maxRetries) {
-                logger.trace("ratelimit_retries_exhausted", {
-                    providerId,
-                    model,
-                    attempt,
-                    maxRetries: tier.maxRetries
-                });
-                logger.error("ratelimit_giveup", { providerId, model, attempts: attempt });
-                return response;
-            }
-            const backoffMs = computeBackoff(snapshot, now());
-            const waitMs = clampWait(backoffMs, tier.maxWaitMs);
-            logger.trace("ratelimit_429_backoff_computed", {
-                providerId,
-                model,
-                attempt: attempt + 1,
-                rawBackoffMs: backoffMs,
-                clampedWaitMs: waitMs,
-                maxWaitMs: tier.maxWaitMs
-            });
-            state.cooldownUntilMs = now() + waitMs;
-            state.cooldownMaxWaitMs = tier.maxWaitMs;
-            logger.trace("ratelimit_cooldown_set", {
-                providerId,
-                model,
-                cooldownUntilMs: state.cooldownUntilMs,
-                maxWaitMs: tier.maxWaitMs,
-                source: "429_backoff"
-            });
-            logger.warn("ratelimit_429_backoff", {
-                providerId,
-                model,
-                attempt: attempt + 1,
-                waitMs,
-                resetSeconds: snapshot.resetSeconds
-            });
-            await waitGate(state, sleep, now, tier.maxWaitMs, signal, logger, providerId, model, "backoff");
-            attempt += 1;
-        }
-    };
-    return wrapped;
+	const now = deps.now ?? Date.now;
+	const sleep = deps.sleep ?? defaultSleep;
+	const underlying = delegate ?? deps.fetchImpl ?? globalThis.fetch;
+	const { logger } = deps;
+	const isRequest = (value) => typeof Request !== "undefined" && value instanceof Request;
+	const wrapped = async (input, init) => {
+		// Honor an abort signal whether it rides on `init` or on a `Request` input.
+		const signal = init?.signal ?? (isRequest(input) ? input.signal : undefined) ?? undefined;
+		const model = opts.scope === "model" ? await modelFromRequest(input, init) : undefined;
+		if (opts.scope === "model") {
+			logger.trace("ratelimit_model_resolved", {
+				providerId,
+				model,
+				matched: model !== undefined
+			});
+		}
+		const key = model ? `${providerId}\u0000${model}` : providerId;
+		let state = store.get(key);
+		const bucketExisted = state !== undefined;
+		if (!state) {
+			state = createProviderState();
+			store.set(key, state);
+		}
+		logger.trace("ratelimit_fetch_invoked", {
+			providerId,
+			scope: opts.scope,
+			model,
+			bucketKey: key,
+			bucketExisted,
+			cooldownUntilMs: state.cooldownUntilMs
+		});
+		// 2. Pre-request gate — wait out a cooldown a previous "wait" tier armed.
+		if (state.cooldownUntilMs > now()) {
+			const waitMs = clampWait(state.cooldownUntilMs - now(), state.cooldownMaxWaitMs);
+			logger.trace("ratelimit_cooldown_gate_armed", {
+				providerId,
+				model,
+				cooldownUntilMs: state.cooldownUntilMs,
+				remainingMs: state.cooldownUntilMs - now(),
+				clampedWaitMs: waitMs,
+				maxWaitMs: state.cooldownMaxWaitMs
+			});
+			if (waitMs > 0) {
+				logger.info("ratelimit_throttle_wait", {
+					providerId,
+					model,
+					waitMs
+				});
+				await waitGate(state, sleep, now, state.cooldownMaxWaitMs, signal, logger, providerId, model, "pre_request");
+			}
+		}
+		// 3-5. Attempt loop.
+		let attempt = 0;
+		for (;;) {
+			// A Request body is single-use; send a fresh clone each attempt so a
+			// wait-tier retry doesn't fail with "body already used". (The original is
+			// never sent directly, so each clone has an unconsumed body.)
+			const attemptInput = isRequest(input) ? input.clone() : input;
+			logger.trace("ratelimit_underlying_fetch", {
+				providerId,
+				model,
+				attempt
+			});
+			const response = await underlying(attemptInput, init);
+			const snapshot = readSnapshot(response, opts, now(), logger, providerId);
+			logger.trace("ratelimit_snapshot_parsed", {
+				providerId,
+				model,
+				status: response.status,
+				limit: snapshot.limit,
+				remaining: snapshot.remaining,
+				resetSeconds: snapshot.resetSeconds,
+				resetAtMs: snapshot.resetAtMs,
+				retryAfterMs: snapshot.retryAfterMs
+			});
+			logger.debug("ratelimit_quota", {
+				providerId,
+				model,
+				remaining: snapshot.remaining,
+				limit: snapshot.limit,
+				resetSeconds: snapshot.resetSeconds
+			});
+			if (response.status !== 429) {
+				// Arm the gate for the NEXT callers when the window is exhausted — but
+				// only under a "wait" tier. An "error" tier wants the next request to
+				// hit a real 429 and be surfaced, so we leave the gate unarmed.
+				if (snapshot.remaining !== undefined && snapshot.remaining <= 0 && snapshot.resetAtMs !== undefined) {
+					const resetForTier = effectiveResetSeconds(snapshot);
+					const tier = selectTier(opts.tiers, resetForTier);
+					logger.trace("ratelimit_exhausted_tier_selected", {
+						providerId,
+						model,
+						resetSeconds: resetForTier,
+						maxResetSeconds: tier.maxResetSeconds,
+						action: tier.action,
+						maxWaitMs: tier.maxWaitMs,
+						maxRetries: tier.maxRetries
+					});
+					if (tier.action === "wait") {
+						state.cooldownUntilMs = snapshot.resetAtMs;
+						state.cooldownMaxWaitMs = tier.maxWaitMs;
+						logger.trace("ratelimit_cooldown_set", {
+							providerId,
+							model,
+							cooldownUntilMs: state.cooldownUntilMs,
+							maxWaitMs: tier.maxWaitMs,
+							source: "exhausted"
+						});
+					} else {
+						// Error tier → don't arm, and drop any stale cooldown a prior
+						// "wait" window left so the next request hits a real 429 at once.
+						state.cooldownUntilMs = 0;
+						state.cooldownMaxWaitMs = 0;
+						logger.trace("ratelimit_cooldown_cleared", {
+							providerId,
+							model,
+							source: "exhausted_error_tier"
+						});
+					}
+				}
+				return response;
+			}
+			const resetForTier = effectiveResetSeconds(snapshot);
+			const tier = selectTier(opts.tiers, resetForTier);
+			logger.trace("ratelimit_429_tier_selected", {
+				providerId,
+				model,
+				attempt,
+				resetSeconds: resetForTier,
+				maxResetSeconds: tier.maxResetSeconds,
+				action: tier.action,
+				maxWaitMs: tier.maxWaitMs,
+				maxRetries: tier.maxRetries
+			});
+			if (tier.action === "error") {
+				// Drop any cooldown a prior "wait" tier armed, so the fail-fast is
+				// actually fast — later requests must not sleep a stale window first.
+				state.cooldownUntilMs = 0;
+				state.cooldownMaxWaitMs = 0;
+				logger.trace("ratelimit_cooldown_cleared", {
+					providerId,
+					model,
+					source: "429_error_tier"
+				});
+				logger.warn("ratelimit_failfast", {
+					providerId,
+					model,
+					resetSeconds: snapshot.resetSeconds
+				});
+				return response;
+			}
+			if (attempt >= tier.maxRetries) {
+				logger.trace("ratelimit_retries_exhausted", {
+					providerId,
+					model,
+					attempt,
+					maxRetries: tier.maxRetries
+				});
+				logger.error("ratelimit_giveup", {
+					providerId,
+					model,
+					attempts: attempt
+				});
+				return response;
+			}
+			const backoffMs = computeBackoff(snapshot, now());
+			const waitMs = clampWait(backoffMs, tier.maxWaitMs);
+			logger.trace("ratelimit_429_backoff_computed", {
+				providerId,
+				model,
+				attempt: attempt + 1,
+				rawBackoffMs: backoffMs,
+				clampedWaitMs: waitMs,
+				maxWaitMs: tier.maxWaitMs
+			});
+			state.cooldownUntilMs = now() + waitMs;
+			state.cooldownMaxWaitMs = tier.maxWaitMs;
+			logger.trace("ratelimit_cooldown_set", {
+				providerId,
+				model,
+				cooldownUntilMs: state.cooldownUntilMs,
+				maxWaitMs: tier.maxWaitMs,
+				source: "429_backoff"
+			});
+			logger.warn("ratelimit_429_backoff", {
+				providerId,
+				model,
+				attempt: attempt + 1,
+				waitMs,
+				resetSeconds: snapshot.resetSeconds
+			});
+			await waitGate(state, sleep, now, tier.maxWaitMs, signal, logger, providerId, model, "backoff");
+			attempt += 1;
+		}
+	};
+	return wrapped;
 }
 /**
- * Best-effort extraction of the `model` from an OpenAI-compatible request.
- * The AI SDK calls `fetch(url, { body: "<json>" })`, so the common path reads a
- * JSON string body synchronously (non-destructive). It also supports the
- * `fetch(new Request(...))` shape by reading a clone of the Request body, so a
- * Request-style caller doesn't silently collapse to the provider-wide bucket.
- * Anything unparseable → `undefined` → caller falls back to the provider bucket.
- */
+* Best-effort extraction of the `model` from an OpenAI-compatible request.
+* The AI SDK calls `fetch(url, { body: "<json>" })`, so the common path reads a
+* JSON string body synchronously (non-destructive). It also supports the
+* `fetch(new Request(...))` shape by reading a clone of the Request body, so a
+* Request-style caller doesn't silently collapse to the provider-wide bucket.
+* Anything unparseable → `undefined` → caller falls back to the provider bucket.
+*/
 async function modelFromRequest(input, init) {
-    const fromInit = modelFromBody(init?.body);
-    if (fromInit !== undefined) {
-        return fromInit;
-    }
-    if (typeof Request !== "undefined" && input instanceof Request) {
-        try {
-            return modelFromBody(await input.clone().text());
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return undefined;
+	const fromInit = modelFromBody(init?.body);
+	if (fromInit !== undefined) {
+		return fromInit;
+	}
+	if (typeof Request !== "undefined" && input instanceof Request) {
+		try {
+			return modelFromBody(await input.clone().text());
+		} catch {
+			return undefined;
+		}
+	}
+	return undefined;
 }
 function modelFromBody(body) {
-    if (typeof body !== "string") {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(body);
-        return typeof parsed.model === "string" && parsed.model.length > 0 ? parsed.model : undefined;
-    }
-    catch {
-        return undefined;
-    }
+	if (typeof body !== "string") {
+		return undefined;
+	}
+	try {
+		const parsed = JSON.parse(body);
+		return typeof parsed.model === "string" && parsed.model.length > 0 ? parsed.model : undefined;
+	} catch {
+		return undefined;
+	}
 }
 /**
- * Reset magnitude (seconds) used for tier selection: prefer `x-ratelimit-reset`,
- * else derive from a `Retry-After` fallback — so a `Retry-After`-only 429 with a
- * multi-day delay still lands in a long-reset (`error`) tier instead of the
- * smallest band.
- */
+* Reset magnitude (seconds) used for tier selection: prefer `x-ratelimit-reset`,
+* else derive from a `Retry-After` fallback — so a `Retry-After`-only 429 with a
+* multi-day delay still lands in a long-reset (`error`) tier instead of the
+* smallest band.
+*/
 function effectiveResetSeconds(snapshot) {
-    if (snapshot.resetSeconds !== undefined) {
-        return snapshot.resetSeconds;
-    }
-    if (snapshot.retryAfterMs !== undefined) {
-        return Math.ceil(snapshot.retryAfterMs / 1000);
-    }
-    return undefined;
+	if (snapshot.resetSeconds !== undefined) {
+		return snapshot.resetSeconds;
+	}
+	if (snapshot.retryAfterMs !== undefined) {
+		return Math.ceil(snapshot.retryAfterMs / 1e3);
+	}
+	return undefined;
 }
 function readSnapshot(response, opts, nowMs, logger, providerId) {
-    try {
-        return parseRateLimit(response.headers, opts.headerPrefix, nowMs);
-    }
-    catch (error) {
-        logger.debug("ratelimit_header_parse_failed", {
-            providerId,
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return {};
-    }
+	try {
+		return parseRateLimit(response.headers, opts.headerPrefix, nowMs);
+	} catch (error) {
+		logger.debug("ratelimit_header_parse_failed", {
+			providerId,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return {};
+	}
 }
 function computeBackoff(snapshot, nowMs) {
-    if (snapshot.resetAtMs !== undefined) {
-        return Math.max(0, snapshot.resetAtMs - nowMs);
-    }
-    if (snapshot.retryAfterMs !== undefined) {
-        return snapshot.retryAfterMs;
-    }
-    return DEFAULT_BACKOFF_MS;
+	if (snapshot.resetAtMs !== undefined) {
+		return Math.max(0, snapshot.resetAtMs - nowMs);
+	}
+	if (snapshot.retryAfterMs !== undefined) {
+		return snapshot.retryAfterMs;
+	}
+	return DEFAULT_BACKOFF_MS;
 }
 /** `maxWaitMs` of 0 means unlimited (wait the full reset window). */
 function clampWait(ms, maxWaitMs) {
-    const nonNegative = Math.max(0, ms);
-    return maxWaitMs > 0 ? Math.min(nonNegative, maxWaitMs) : nonNegative;
+	const nonNegative = Math.max(0, ms);
+	return maxWaitMs > 0 ? Math.min(nonNegative, maxWaitMs) : nonNegative;
 }
 /**
- * Wait until `state.cooldownUntilMs` has elapsed. Two concurrency properties:
- *
- *  - **One shared timer.** The first caller to hit the gate creates the timer on
- *    `state.cooldownPromise`; concurrent callers await that same timer rather
- *    than each starting their own, so a burst during cooldown produces ONE wait,
- *    not N. The shared timer is not tied to any single caller's `signal` — each
- *    caller races it against its own signal (see `raceWithAbort`), so one
- *    request's cancellation never aborts the others.
- *  - **Honors the longest window.** After the shared timer resolves we re-check
- *    `cooldownUntilMs`. If another caller extended the window (e.g. a 429 landed
- *    with a further-out reset) while we were waiting we wait again for the
- *    remainder instead of returning early and hammering the gateway.
- *
- * `maxWaitMs` (when > 0) bounds the TOTAL wait of a single call: once a caller
- * has waited that long it proceeds even if the window hasn't fully elapsed. A
- * caller that needs LESS than the in-flight shared timer (the window shrank, or
- * the timer was created by a caller with a later deadline) falls back to its own
- * private sleep so it is never held past its own required time.
- */
+* Wait until `state.cooldownUntilMs` has elapsed. Two concurrency properties:
+*
+*  - **One shared timer.** The first caller to hit the gate creates the timer on
+*    `state.cooldownPromise`; concurrent callers await that same timer rather
+*    than each starting their own, so a burst during cooldown produces ONE wait,
+*    not N. The shared timer is not tied to any single caller's `signal` — each
+*    caller races it against its own signal (see `raceWithAbort`), so one
+*    request's cancellation never aborts the others.
+*  - **Honors the longest window.** After the shared timer resolves we re-check
+*    `cooldownUntilMs`. If another caller extended the window (e.g. a 429 landed
+*    with a further-out reset) while we were waiting we wait again for the
+*    remainder instead of returning early and hammering the gateway.
+*
+* `maxWaitMs` (when > 0) bounds the TOTAL wait of a single call: once a caller
+* has waited that long it proceeds even if the window hasn't fully elapsed. A
+* caller that needs LESS than the in-flight shared timer (the window shrank, or
+* the timer was created by a caller with a later deadline) falls back to its own
+* private sleep so it is never held past its own required time.
+*/
 async function waitGate(state, sleep, now, maxWaitMs, signal, logger, providerId, model, phase) {
-    const deadlineMs = maxWaitMs > 0 ? now() + maxWaitMs : Number.POSITIVE_INFINITY;
-    logger.trace("ratelimit_wait_start", {
-        providerId,
-        model,
-        phase,
-        cooldownUntilMs: state.cooldownUntilMs,
-        maxWaitMs
-    });
-    for (;;) {
-        const target = Math.min(state.cooldownUntilMs, deadlineMs);
-        const remainingMs = target - now();
-        if (remainingMs <= 0) {
-            logger.trace("ratelimit_wait_end", { providerId, model, phase });
-            return;
-        }
-        logger.trace("ratelimit_wait_tick", {
-            providerId,
-            model,
-            phase,
-            remainingMs,
-            sharedTimer: state.cooldownPromise !== undefined
-        });
-        // Reuse the shared timer only if it won't make us wait longer than we need.
-        let pending = state.cooldownPromise;
-        if (pending &&
-            state.cooldownPromiseUntilMs !== undefined &&
-            state.cooldownPromiseUntilMs - now() > remainingMs) {
-            pending = undefined;
-        }
-        if (!pending) {
-            const created = sleep(remainingMs).finally(() => {
-                if (state.cooldownPromise === created) {
-                    state.cooldownPromise = undefined;
-                    state.cooldownPromiseUntilMs = undefined;
-                }
-            });
-            // Publish as the shared timer only when there isn't already a (shorter)
-            // one in flight — never clobber it with our longer/private wait.
-            if (!state.cooldownPromise) {
-                state.cooldownPromise = created;
-                state.cooldownPromiseUntilMs = now() + remainingMs;
-            }
-            pending = created;
-        }
-        try {
-            await raceWithAbort(pending, signal);
-        }
-        catch (error) {
-            if (isAbortError(error)) {
-                logger.warn("ratelimit_wait_aborted", { providerId, model, phase });
-            }
-            throw error;
-        }
-        // Loop: re-check in case the window was extended while we waited.
-    }
+	const deadlineMs = maxWaitMs > 0 ? now() + maxWaitMs : Number.POSITIVE_INFINITY;
+	logger.trace("ratelimit_wait_start", {
+		providerId,
+		model,
+		phase,
+		cooldownUntilMs: state.cooldownUntilMs,
+		maxWaitMs
+	});
+	for (;;) {
+		const target = Math.min(state.cooldownUntilMs, deadlineMs);
+		const remainingMs = target - now();
+		if (remainingMs <= 0) {
+			logger.trace("ratelimit_wait_end", {
+				providerId,
+				model,
+				phase
+			});
+			return;
+		}
+		logger.trace("ratelimit_wait_tick", {
+			providerId,
+			model,
+			phase,
+			remainingMs,
+			sharedTimer: state.cooldownPromise !== undefined
+		});
+		// Reuse the shared timer only if it won't make us wait longer than we need.
+		let pending = state.cooldownPromise;
+		if (pending && state.cooldownPromiseUntilMs !== undefined && state.cooldownPromiseUntilMs - now() > remainingMs) {
+			pending = undefined;
+		}
+		if (!pending) {
+			const created = sleep(remainingMs).finally(() => {
+				if (state.cooldownPromise === created) {
+					state.cooldownPromise = undefined;
+					state.cooldownPromiseUntilMs = undefined;
+				}
+			});
+			// Publish as the shared timer only when there isn't already a (shorter)
+			// one in flight — never clobber it with our longer/private wait.
+			if (!state.cooldownPromise) {
+				state.cooldownPromise = created;
+				state.cooldownPromiseUntilMs = now() + remainingMs;
+			}
+			pending = created;
+		}
+		try {
+			await raceWithAbort(pending, signal);
+		} catch (error) {
+			if (isAbortError(error)) {
+				logger.warn("ratelimit_wait_aborted", {
+					providerId,
+					model,
+					phase
+				});
+			}
+			throw error;
+		}
+	}
 }
 function raceWithAbort(promise, signal) {
-    if (!signal) {
-        return promise;
-    }
-    if (signal.aborted) {
-        return Promise.reject(toAbortError(signal));
-    }
-    return new Promise((resolve, reject) => {
-        const onAbort = () => reject(toAbortError(signal));
-        signal.addEventListener("abort", onAbort, { once: true });
-        promise.then(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, (error) => {
-            signal.removeEventListener("abort", onAbort);
-            reject(error);
-        });
-    });
+	if (!signal) {
+		return promise;
+	}
+	if (signal.aborted) {
+		return Promise.reject(toAbortError(signal));
+	}
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(toAbortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
 }
 function defaultSleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(toAbortError(signal));
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(toAbortError(signal));
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(toAbortError(signal));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(toAbortError(signal));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
 }
 function toAbortError(signal) {
-    const reason = signal.reason;
-    if (reason instanceof Error) {
-        return reason;
-    }
-    return new DOMException("The operation was aborted", "AbortError");
+	const reason = signal.reason;
+	if (reason instanceof Error) {
+		return reason;
+	}
+	return new DOMException("The operation was aborted", "AbortError");
 }
 function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
+	return error instanceof Error && error.name === "AbortError";
 }
+
 //# sourceMappingURL=plugin.js.map