@happyvertical/ai 0.97.0 → 0.98.0

package/dist/chunks/rate-limit-BzWfHA0e.js

@@ -0,0 +1,713 @@
+import { c as RateLimitError, o as DEFAULT_RATE_LIMIT_MAX_RETRY_DELAY_MS, t as AIError, u as isRateLimitRetryableSoon } from "./types-DB5W6_F-.js";
+//#region src/shared/safety.ts
+var DEFAULT_AI_TIMEOUT_MS = 12e4;
+var DEFAULT_AI_MAX_RETRIES = 0;
+var DEFAULT_AI_GENERATION_LIMITS = Object.freeze({
+	maxOutputTokens: 131072,
+	defaultOutputTokens: 4096,
+	maxReasoningTokens: 1024,
+	maxImagesPerRequest: 1,
+	onExceeded: "error"
+});
+function positiveInteger(value, fallback, field) {
+	if (value === void 0) return fallback;
+	if (!Number.isFinite(value) || value <= 0) throw new AIError(`${field} must be a positive finite number`, "AI_LIMIT_INVALID");
+	return Math.trunc(value);
+}
+function normalizeBaseAIOptions(options) {
+	const configuredLimits = options.generationLimits || {};
+	const generationLimits = {
+		maxOutputTokens: positiveInteger(configuredLimits.maxOutputTokens, DEFAULT_AI_GENERATION_LIMITS.maxOutputTokens, "generationLimits.maxOutputTokens"),
+		defaultOutputTokens: Math.min(positiveInteger(configuredLimits.defaultOutputTokens, DEFAULT_AI_GENERATION_LIMITS.defaultOutputTokens, "generationLimits.defaultOutputTokens"), positiveInteger(configuredLimits.maxOutputTokens, DEFAULT_AI_GENERATION_LIMITS.maxOutputTokens, "generationLimits.maxOutputTokens")),
+		maxReasoningTokens: positiveInteger(configuredLimits.maxReasoningTokens, DEFAULT_AI_GENERATION_LIMITS.maxReasoningTokens, "generationLimits.maxReasoningTokens"),
+		maxImagesPerRequest: positiveInteger(configuredLimits.maxImagesPerRequest, DEFAULT_AI_GENERATION_LIMITS.maxImagesPerRequest, "generationLimits.maxImagesPerRequest"),
+		onExceeded: configuredLimits.onExceeded || DEFAULT_AI_GENERATION_LIMITS.onExceeded
+	};
+	if (!["error", "clamp"].includes(generationLimits.onExceeded)) throw new AIError("generationLimits.onExceeded must be \"error\" or \"clamp\"", "AI_LIMIT_INVALID");
+	return {
+		...options,
+		timeout: positiveInteger(options.timeout, DEFAULT_AI_TIMEOUT_MS, "timeout"),
+		maxRetries: (() => {
+			if (options.maxRetries === void 0) return 0;
+			if (!Number.isFinite(options.maxRetries) || options.maxRetries < 0) throw new AIError("maxRetries must be a non-negative finite number", "AI_LIMIT_INVALID");
+			return Math.trunc(options.maxRetries);
+		})(),
+		generationLimits
+	};
+}
+function reasoningTokensForEffort(effort) {
+	switch (effort) {
+		case false:
+		case "none": return 0;
+		case "minimal": return 1024;
+		case "low": return 2048;
+		case "medium": return 4096;
+		case "high": return 8192;
+		default: return;
+	}
+}
+function enforceLimit(requested, limit, behavior, label, provider, model) {
+	if (!Number.isFinite(requested) || requested < 0) throw new AIError(`${label} must be a non-negative finite number`, "AI_LIMIT_INVALID", provider, model);
+	const normalized = Math.trunc(requested);
+	if (normalized <= limit) return normalized;
+	if (behavior === "clamp") return limit;
+	throw new AIError(`${label} ${normalized} exceeds configured ceiling ${limit}`, "AI_LIMIT_EXCEEDED", provider, model);
+}
+function normalizeChatOptions(providerOptions, options, provider, model) {
+	const limits = normalizeBaseAIOptions(providerOptions).generationLimits;
+	const requestedOutput = options.maxTokens ?? limits.defaultOutputTokens ?? limits.maxOutputTokens;
+	const legacyEffort = options.thinkingLevel ?? providerOptions.thinkingLevel;
+	const requestedReasoning = options.reasoning !== void 0 || legacyEffort !== void 0 || options.includeThoughts === true ? options.reasoning?.maxTokens ?? reasoningTokensForEffort(options.reasoning?.effort ?? legacyEffort) ?? limits.maxReasoningTokens : 0;
+	return {
+		...options,
+		maxTokens: enforceLimit(requestedOutput, limits.maxOutputTokens, limits.onExceeded, "maxTokens", provider, model),
+		reasoning: {
+			...options.reasoning,
+			maxTokens: enforceLimit(requestedReasoning, limits.maxReasoningTokens, limits.onExceeded, "reasoning.maxTokens", provider, model),
+			includeThoughts: options.reasoning?.includeThoughts ?? options.includeThoughts
+		}
+	};
+}
+function normalizeImageGenerationOptions(providerOptions, options, provider, model) {
+	const limits = normalizeBaseAIOptions(providerOptions).generationLimits;
+	return {
+		...options,
+		n: enforceLimit(options.n ?? 1, limits.maxImagesPerRequest, limits.onExceeded, "n", provider, model)
+	};
+}
+function prepareRequestControls(providerOptions, requestOptions = {}) {
+	const normalized = normalizeBaseAIOptions(providerOptions);
+	const timeout = positiveInteger(requestOptions.timeout, normalized.timeout, "timeout");
+	const controller = new AbortController();
+	let timedOut = false;
+	const abortFromCaller = () => controller.abort(requestOptions.signal?.reason);
+	if (requestOptions.signal?.aborted) abortFromCaller();
+	else requestOptions.signal?.addEventListener("abort", abortFromCaller, { once: true });
+	const timer = setTimeout(() => {
+		timedOut = true;
+		controller.abort(/* @__PURE__ */ new Error(`AI request timed out after ${timeout}ms`));
+	}, timeout);
+	return {
+		signal: controller.signal,
+		timeout,
+		didTimeout: () => timedOut,
+		cleanup: () => {
+			clearTimeout(timer);
+			requestOptions.signal?.removeEventListener("abort", abortFromCaller);
+		}
+	};
+}
+function mergeTags(providerOptions, callTags) {
+	return providerOptions.usageTags || callTags ? {
+		...providerOptions.usageTags,
+		...callTags
+	} : void 0;
+}
+function emitRequestEvent(providerOptions, event) {
+	if (!providerOptions.onRequest) return;
+	try {
+		providerOptions.onRequest({
+			...event,
+			tags: mergeTags(providerOptions, event.tags)
+		});
+	} catch {}
+}
+function classifyRequestFailure(error, didTimeout = false) {
+	const code = error instanceof AIError ? error.code : void 0;
+	if (code === "AI_LIMIT_EXCEEDED" || code === "AI_LIMIT_INVALID") return {
+		status: "rejected",
+		errorCode: code
+	};
+	if (didTimeout || code === "AI_TIMEOUT" || code === "TIMEOUT" || code === "REQUEST_TIMEOUT") return {
+		status: "timed_out",
+		errorCode: code || "AI_TIMEOUT"
+	};
+	if (error instanceof Error && error.name === "AbortError") return {
+		status: "aborted",
+		errorCode: "ABORTED"
+	};
+	if (code === "AI_ABORTED" || code === "REQUEST_ABORTED") return {
+		status: "aborted",
+		errorCode: code
+	};
+	return {
+		status: "failed",
+		errorCode: code || (error instanceof Error ? error.name : void 0)
+	};
+}
+function requestEventBase(options) {
+	const normalized = normalizeBaseAIOptions(options.providerOptions);
+	return {
+		provider: options.provider,
+		model: options.model,
+		operation: options.operation,
+		attempts: normalized.maxRetries + 1,
+		requestedMaxOutputTokens: options.operation === "decide" ? void 0 : options.callOptions?.maxTokens,
+		effectiveMaxOutputTokens: options.operation === "decide" || options.operation === "generateImage" || VIDEO_GENERATION_OPERATIONS.has(options.operation) ? void 0 : options.effectiveMaxOutputTokens ?? Math.min(options.callOptions?.maxTokens ?? normalized.generationLimits.defaultOutputTokens ?? normalized.generationLimits.maxOutputTokens, normalized.generationLimits.maxOutputTokens),
+		tags: options.callOptions?.usageTags
+	};
+}
+var OBSERVED_OPERATIONS = /* @__PURE__ */ new Set([
+	"decide",
+	"chat",
+	"complete",
+	"message",
+	"describeImage",
+	"generateImage",
+	"stream",
+	"submitVideoGenerationJob",
+	"getVideoGenerationJob",
+	"fetchVideoGenerationResult",
+	"cancelVideoGenerationJob"
+]);
+/**
+* `getVideoGenerationJob` / `fetchVideoGenerationResult` /
+* `cancelVideoGenerationJob` take a `VideoGenerationJob` handle as their
+* first (and only) argument rather than a chat-shaped `options` object as
+* the second argument. The handle still carries a `model` field, so
+* `callOptionsFor` reads it from the same position as `submitVideoGenerationJob`'s
+* `options` (index 0) rather than index 1.
+*/
+var VIDEO_HANDLE_OPERATIONS = /* @__PURE__ */ new Set([
+	"getVideoGenerationJob",
+	"fetchVideoGenerationResult",
+	"cancelVideoGenerationJob"
+]);
+var VIDEO_GENERATION_OPERATIONS = /* @__PURE__ */ new Set(["submitVideoGenerationJob", ...VIDEO_HANDLE_OPERATIONS]);
+function callOptionsFor(operation, args) {
+	const value = args[operation === "decide" ? 1 : operation === "describeImage" ? 2 : operation === "submitVideoGenerationJob" || VIDEO_HANDLE_OPERATIONS.has(operation) ? 0 : 1];
+	return value && typeof value === "object" ? value : void 0;
+}
+function providerName(options) {
+	return options.type || "openai";
+}
+function effectiveOutputTokens(operation, providerOptions, callOptions) {
+	if (operation === "decide" || operation === "generateImage" || VIDEO_GENERATION_OPERATIONS.has(operation)) {
+		if (operation === "generateImage") normalizeImageGenerationOptions(providerOptions, callOptions || {}, providerName(providerOptions), callOptions?.model);
+		return;
+	}
+	return normalizeChatOptions(providerOptions, callOptions || {}, providerName(providerOptions), callOptions?.model || providerOptions.defaultModel).maxTokens;
+}
+/**
+* Wrap a public provider instance with prompt-free lifecycle observation.
+* Provider adapters still enforce limits internally so direct construction is
+* protected; this wrapper adds one terminal event to the public getAI() path.
+*/
+function createObservedAI(client, providerOptions) {
+	if (!providerOptions.onRequest) return client;
+	return new Proxy(client, { get(target, property, receiver) {
+		const value = Reflect.get(target, property, receiver);
+		if (typeof property !== "string" || typeof value !== "function" || !OBSERVED_OPERATIONS.has(property)) return typeof value === "function" ? value.bind(target) : value;
+		const operation = property;
+		if (operation === "stream") return async function* (...args) {
+			const startedAt = Date.now();
+			const callOptions = callOptionsFor(operation, args);
+			let base;
+			try {
+				base = requestEventBase({
+					providerOptions,
+					provider: providerName(providerOptions),
+					model: callOptions?.model || providerOptions.defaultModel || "unknown",
+					operation,
+					callOptions,
+					effectiveMaxOutputTokens: effectiveOutputTokens(operation, providerOptions, callOptions)
+				});
+				const iterable = Reflect.apply(value, target, args);
+				for await (const chunk of iterable) yield chunk;
+				emitRequestEvent(providerOptions, {
+					...base,
+					status: "succeeded",
+					duration: Date.now() - startedAt
+				});
+			} catch (error) {
+				const failure = classifyRequestFailure(error);
+				base ||= requestEventBase({
+					providerOptions,
+					provider: providerName(providerOptions),
+					model: callOptions?.model || providerOptions.defaultModel || "unknown",
+					operation,
+					callOptions
+				});
+				emitRequestEvent(providerOptions, {
+					...base,
+					...failure,
+					duration: Date.now() - startedAt
+				});
+				throw error;
+			}
+		};
+		return async (...args) => {
+			const startedAt = Date.now();
+			const callOptions = callOptionsFor(operation, args);
+			let base;
+			try {
+				base = requestEventBase({
+					providerOptions,
+					provider: providerName(providerOptions),
+					model: callOptions?.model || providerOptions.defaultModel || "unknown",
+					operation,
+					callOptions,
+					effectiveMaxOutputTokens: effectiveOutputTokens(operation, providerOptions, callOptions)
+				});
+				const result = await Reflect.apply(value, target, args);
+				emitRequestEvent(providerOptions, {
+					...base,
+					status: "succeeded",
+					duration: Date.now() - startedAt
+				});
+				return result;
+			} catch (error) {
+				const failure = classifyRequestFailure(error);
+				base ||= requestEventBase({
+					providerOptions,
+					provider: providerName(providerOptions),
+					model: callOptions?.model || providerOptions.defaultModel || "unknown",
+					operation,
+					callOptions
+				});
+				emitRequestEvent(providerOptions, {
+					...base,
+					...failure,
+					duration: Date.now() - startedAt
+				});
+				throw error;
+			}
+		};
+	} });
+}
+//#endregion
+//#region src/shared/rate-limit.ts
+var RATE_LIMITED_METHODS = /* @__PURE__ */ new Set([
+	"decide",
+	"chat",
+	"complete",
+	"message",
+	"embed",
+	"embedImage",
+	"describeImage",
+	"generateImage",
+	"getModels",
+	"synthesizeSpeech",
+	"cloneVoice",
+	"designVoice",
+	"getVoices",
+	"submitVideoGenerationJob"
+]);
+/**
+* Where each paced method takes its request controls (`timeout`, `signal`).
+* For these, the timeout covers the whole call: time queued behind other calls
+* on the same key, pacing and retry waits, and the request itself.
+*/
+var REQUEST_CONTROLS_INDEX = {
+	decide: 1,
+	chat: 1,
+	complete: 1,
+	message: 1,
+	describeImage: 2,
+	generateImage: 1,
+	submitVideoGenerationJob: 0
+};
+var MAX_BUDGET_COORDINATORS = 128;
+var BUDGET_COORDINATOR_TTL_MS = 900 * 1e3;
+function queueTimeoutError(budget) {
+	return new AIError(`AI request timed out after ${budget.timeoutMs}ms, including time waiting for its rate-limit turn`, "AI_TIMEOUT", budget.provider);
+}
+function abortedError(budget) {
+	return new AIError("AI request aborted by caller", "AI_ABORTED", budget.provider);
+}
+var BudgetCoordinator = class {
+	nextAvailableAt = 0;
+	pendingSchedules = 0;
+	tail = Promise.resolve();
+	lastUsedAt = Date.now();
+	/** The rate-limit error that holds the key closed until `blockedUntil`. */
+	blockedBy;
+	blockedUntil = 0;
+	touch() {
+		this.lastUsedAt = Date.now();
+	}
+	/**
+	* Run `work` after every earlier call on this key. While the call is still
+	* queued, its deadline or abort signal releases the caller, and the work is
+	* skipped when its turn comes.
+	*/
+	schedule(work, budget) {
+		this.pendingSchedules += 1;
+		this.touch();
+		let gaveUp;
+		let started;
+		const guarded = () => {
+			if (gaveUp) return Promise.reject(gaveUp);
+			started?.();
+			return work();
+		};
+		const run = this.tail.then(guarded, guarded);
+		this.tail = run.then(() => void 0, () => void 0);
+		const result = run.finally(() => {
+			this.pendingSchedules = Math.max(0, this.pendingSchedules - 1);
+			this.touch();
+		});
+		if (budget.deadline === void 0 && !budget.signal) return result;
+		return new Promise((resolve, reject) => {
+			let timer;
+			const stopWaiting = () => {
+				if (timer) clearTimeout(timer);
+				budget.signal?.removeEventListener("abort", onAbort);
+			};
+			const giveUp = (error) => {
+				gaveUp = error;
+				stopWaiting();
+				reject(error);
+			};
+			const onAbort = () => giveUp(abortedError(budget));
+			started = stopWaiting;
+			if (budget.deadline !== void 0) timer = setTimeout(() => giveUp(queueTimeoutError(budget)), Math.max(0, budget.deadline - Date.now()));
+			if (budget.signal?.aborted) onAbort();
+			else budget.signal?.addEventListener("abort", onAbort, { once: true });
+			result.then((value) => {
+				stopWaiting();
+				resolve(value);
+			}, (error) => {
+				stopWaiting();
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Wait out pacing before a request. When the wait would run past the call's
+	* deadline, fail now: with a RateLimitError (reason and time until the key
+	* reopens) when a rate limit closed the key, else with a timeout.
+	*/
+	async waitUntilReady(budget, config) {
+		this.touch();
+		const now = Date.now();
+		const delayMs = this.nextAvailableAt - now;
+		if (delayMs > 0) {
+			if (budget.deadline !== void 0 && now + delayMs >= budget.deadline) {
+				const blockedBy = this.blockedUntil > now ? this.blockedBy : void 0;
+				if (blockedBy) throw new RateLimitError(blockedBy.provider, void 0, {
+					reason: blockedBy.reason,
+					retryAfterMs: Math.max(0, this.blockedUntil - now),
+					limitWindowMs: blockedBy.limitWindowMs,
+					model: blockedBy.model,
+					cause: blockedBy,
+					maxRetryDelayMs: config.maxRetryDelayMs
+				});
+				throw queueTimeoutError(budget);
+			}
+			await sleep(delayMs, budget.signal);
+			if (budget.signal?.aborted) throw abortedError(budget);
+		}
+	}
+	delayFor(delayMs, cause) {
+		this.touch();
+		if (delayMs <= 0) return;
+		const until = Date.now() + delayMs;
+		this.nextAvailableAt = Math.max(this.nextAvailableAt, until);
+		if (cause && until >= this.blockedUntil) {
+			this.blockedBy = cause;
+			this.blockedUntil = until;
+		}
+	}
+	isEvictable(now) {
+		return this.pendingSchedules === 0 && now >= this.nextAvailableAt;
+	}
+	isExpired(now) {
+		return this.isEvictable(now) && now - this.lastUsedAt >= BUDGET_COORDINATOR_TTL_MS;
+	}
+	getLastUsedAt() {
+		return this.lastUsedAt;
+	}
+};
+var budgetCoordinators = /* @__PURE__ */ new Map();
+/** Sleep; an abort ends the sleep early (the caller checks the signal). */
+function sleep(delayMs, signal) {
+	return new Promise((resolve) => {
+		const done = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, delayMs);
+		signal?.addEventListener("abort", done, { once: true });
+	});
+}
+function pruneBudgetCoordinators() {
+	const now = Date.now();
+	for (const [key, coordinator] of budgetCoordinators.entries()) if (coordinator.isExpired(now)) budgetCoordinators.delete(key);
+	while (budgetCoordinators.size > MAX_BUDGET_COORDINATORS) {
+		const evictableEntries = [...budgetCoordinators.entries()].filter(([, coordinator]) => coordinator.isEvictable(now)).sort(([, leftCoordinator], [, rightCoordinator]) => leftCoordinator.getLastUsedAt() - rightCoordinator.getLastUsedAt());
+		if (evictableEntries.length === 0) break;
+		budgetCoordinators.delete(evictableEntries[0][0]);
+	}
+}
+function getBudgetCoordinator(key) {
+	pruneBudgetCoordinators();
+	let coordinator = budgetCoordinators.get(key);
+	if (!coordinator) {
+		coordinator = new BudgetCoordinator();
+		budgetCoordinators.set(key, coordinator);
+		pruneBudgetCoordinators();
+	}
+	coordinator.touch();
+	return coordinator;
+}
+function hasPacingConfig(rateLimit) {
+	if (!rateLimit || rateLimit.enabled === false) return false;
+	return rateLimit.enabled === true || rateLimit.key !== void 0 || rateLimit.cooldownMs !== void 0 || rateLimit.initialDelayMs !== void 0 || rateLimit.maxAttempts !== void 0 || rateLimit.maxRetryDelayMs !== void 0;
+}
+function normalizeNonNegativeInteger(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.trunc(value));
+}
+function hashKey(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function deriveBudgetKey(options) {
+	const type = options.type;
+	const provider = typeof type === "string" && type ? type : "openai";
+	const seed = [
+		"apiKey" in options ? options.apiKey : void 0,
+		"apiToken" in options ? options.apiToken : void 0,
+		"credentials" in options ? options.credentials?.accessKeyId : void 0,
+		"endpoint" in options ? options.endpoint : void 0,
+		"baseUrl" in options ? options.baseUrl : void 0,
+		"cliPath" in options ? options.cliPath : void 0
+	].find((value) => typeof value === "string" && value.length > 0);
+	return seed ? `${provider}:${hashKey(seed)}` : `${provider}:default`;
+}
+function normalizeRateLimitConfig(options) {
+	const rateLimit = "rateLimit" in options ? options.rateLimit : void 0;
+	if (!hasPacingConfig(rateLimit)) return null;
+	return {
+		cooldownMs: normalizeNonNegativeInteger(rateLimit?.cooldownMs, 0),
+		initialDelayMs: normalizeNonNegativeInteger(rateLimit?.initialDelayMs, 5e3),
+		key: rateLimit?.key?.trim() || deriveBudgetKey(options),
+		maxAttempts: Math.max(1, normalizeNonNegativeInteger(rateLimit?.maxAttempts, 1)),
+		maxRetryDelayMs: normalizeNonNegativeInteger(rateLimit?.maxRetryDelayMs, DEFAULT_RATE_LIMIT_MAX_RETRY_DELAY_MS)
+	};
+}
+function getRetryDelayMs(error, config) {
+	const hintedDelayMs = typeof error.retryAfterMs === "number" && Number.isFinite(error.retryAfterMs) ? Math.max(0, Math.ceil(error.retryAfterMs)) : typeof error.retryAfter === "number" && Number.isFinite(error.retryAfter) ? Math.max(0, Math.ceil(error.retryAfter * 1e3)) : void 0;
+	if (hintedDelayMs !== void 0) return Math.max(config.cooldownMs, hintedDelayMs);
+	return Math.max(config.cooldownMs, config.initialDelayMs);
+}
+async function invokeWithPacing(execute, coordinator, config, budget, allowRetry = true) {
+	let attempt = 1;
+	while (true) {
+		await coordinator.waitUntilReady(budget, config);
+		const remainingMs = budget.deadline === void 0 ? void 0 : budget.deadline - Date.now();
+		if (remainingMs !== void 0 && remainingMs <= 0) throw queueTimeoutError(budget);
+		try {
+			const result = await execute(remainingMs);
+			coordinator.delayFor(config.cooldownMs);
+			return result;
+		} catch (error) {
+			if (error instanceof RateLimitError) {
+				const retryDelayMs = getRetryDelayMs(error, config);
+				coordinator.delayFor(retryDelayMs, error);
+				error.retryable = isRateLimitRetryableSoon(error.retryAfterMs ?? error.limitWindowMs, config.maxRetryDelayMs);
+				const fitsDeadline = budget.deadline === void 0 || Date.now() + retryDelayMs < budget.deadline;
+				if (allowRetry && error.retryable && fitsDeadline && attempt < config.maxAttempts) {
+					attempt += 1;
+					continue;
+				}
+			}
+			throw error;
+		}
+	}
+}
+function parseRetryAfterSeconds(retryAfter) {
+	if (typeof retryAfter === "number" && Number.isFinite(retryAfter)) return Math.max(0, retryAfter);
+	if (typeof retryAfter !== "string") return;
+	const trimmed = retryAfter.trim();
+	if (!trimmed) return;
+	const seconds = Number.parseFloat(trimmed);
+	if (!Number.isNaN(seconds)) return Math.max(0, seconds);
+	const retryAt = Date.parse(trimmed);
+	if (Number.isNaN(retryAt)) return;
+	return Math.max(0, Math.ceil((retryAt - Date.now()) / 1e3));
+}
+function getHeaderValue(headers, headerName) {
+	if (!headers || typeof headers !== "object") return;
+	if ("get" in headers && typeof headers.get === "function") return headers.get(headerName) ?? headers.get(headerName.toLowerCase());
+	const objectHeaders = headers;
+	return objectHeaders[headerName] ?? objectHeaders[headerName.toLowerCase()];
+}
+function extractRetryAfterSeconds(error) {
+	if (!error || typeof error !== "object") return;
+	if ("retryAfter" in error) {
+		const retryAfter = parseRetryAfterSeconds(error.retryAfter);
+		if (retryAfter !== void 0) return retryAfter;
+	}
+	if ("headers" in error) {
+		const retryAfter = parseRetryAfterSeconds(getHeaderValue(error.headers, "retry-after"));
+		if (retryAfter !== void 0) return retryAfter;
+	}
+	const message = "message" in error && typeof error.message === "string" ? error.message : "";
+	const retryAfterMatch = message.match(/retry after\s+(\d+(?:\.\d+)?)\s*s?/i) ?? message.match(/retryDelay[^\d]*(\d+(?:\.\d+)?)s/i);
+	return retryAfterMatch ? parseRetryAfterSeconds(retryAfterMatch[1]) : void 0;
+}
+var DURATION_UNITS_MS = {
+	ms: 1,
+	millisecond: 1,
+	milliseconds: 1,
+	s: 1e3,
+	sec: 1e3,
+	secs: 1e3,
+	second: 1e3,
+	seconds: 1e3,
+	m: 6e4,
+	min: 6e4,
+	mins: 6e4,
+	minute: 6e4,
+	minutes: 6e4,
+	h: 36e5,
+	hr: 36e5,
+	hrs: 36e5,
+	hour: 36e5,
+	hours: 36e5,
+	d: 864e5,
+	day: 864e5,
+	days: 864e5
+};
+var DURATION_PART = "\\d+(?:\\.\\d+)?\\s*(?:milliseconds?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)(?![a-z])";
+var DURATION = `${DURATION_PART}(?:\\s*${DURATION_PART})*`;
+/**
+* Parse a duration such as `20s`, `6m0s`, `1h`, `250ms` or `2 minutes` into
+* milliseconds. Returns undefined for anything else.
+*/
+function parseDurationMs(text) {
+	const trimmed = text.trim();
+	if (!new RegExp(`^${DURATION}$`, "i").test(trimmed)) return void 0;
+	let total = 0;
+	for (const match of trimmed.matchAll(/(\d+(?:\.\d+)?)\s*([a-z]+)/gi)) total += Number.parseFloat(match[1]) * DURATION_UNITS_MS[match[2].toLowerCase()];
+	return Number.isFinite(total) ? Math.ceil(total) : void 0;
+}
+/** Reset headers that name when a limit lifts, as a duration or a timestamp. */
+var RESET_HEADERS = [
+	"x-ratelimit-reset-requests",
+	"x-ratelimit-reset-tokens",
+	"anthropic-ratelimit-requests-reset",
+	"anthropic-ratelimit-tokens-reset",
+	"anthropic-ratelimit-input-tokens-reset",
+	"anthropic-ratelimit-output-tokens-reset"
+];
+function resetHeaderMs(headers) {
+	let latest;
+	for (const name of RESET_HEADERS) {
+		const raw = getHeaderValue(headers, name);
+		if (raw === void 0 || raw === null || raw === "") continue;
+		const text = String(raw).trim();
+		let ms = parseDurationMs(text);
+		if (ms === void 0 && /\d{4}-\d{2}-\d{2}T/.test(text)) {
+			const at = Date.parse(text);
+			if (!Number.isNaN(at)) ms = Math.max(0, at - Date.now());
+		}
+		if (ms !== void 0) latest = Math.max(latest ?? 0, ms);
+	}
+	return latest;
+}
+function stringAt(value, ...path) {
+	let current = value;
+	for (const key of path) {
+		if (!current || typeof current !== "object") return void 0;
+		current = current[key];
+	}
+	return typeof current === "string" && current.trim() ? current : void 0;
+}
+/**
+* The provider's own reason text from an SDK error or response body, for
+* example `token limit exceeded (277867/250000, resets every 1h)`.
+*/
+function extractRateLimitReason(error) {
+	const fromBody = stringAt(error, "error", "error", "message") ?? stringAt(error, "error", "message") ?? stringAt(error, "body", "error", "message") ?? stringAt(error, "body", "message");
+	if (fromBody) return fromBody;
+	const message = stringAt(error, "message");
+	if (!message) return void 0;
+	if (/^\s*\{/.test(message)) try {
+		const body = JSON.parse(message);
+		const text = stringAt(body, "error", "message") ?? stringAt(body, "message") ?? stringAt(body, "error");
+		if (text) return text;
+	} catch {}
+	const reason = message.replace(/^\d{3}\s+/, "").trim();
+	return /^(?:status code \(no body\)|too many requests|rate limit(?:ed| exceeded)?)\.?$/i.test(reason) ? void 0 : reason;
+}
+/**
+* Build a RateLimitError that keeps what the provider said: its reason text,
+* any `Retry-After` or reset hint (headers or text), and a named limit window.
+*/
+function rateLimitErrorFrom(provider, error, extra = {}) {
+	const reason = extra.reason?.trim() || extractRateLimitReason(error);
+	const retryAfter = extractRetryAfterSeconds(error);
+	const headers = error && typeof error === "object" && "headers" in error ? error.headers : void 0;
+	let retryAfterMs = retryAfter !== void 0 ? retryAfter * 1e3 : resetHeaderMs(headers);
+	let limitWindowMs;
+	if (reason) {
+		if (retryAfterMs === void 0) {
+			const inMatch = reason.match(new RegExp(`(?:try again|retry|resets?|available)\\s+in\\s+(${DURATION})`, "i"));
+			if (inMatch) retryAfterMs = parseDurationMs(inMatch[1]);
+		}
+		const everyMatch = reason.match(new RegExp(`resets?\\s+(?:every|each)\\s+(${DURATION})`, "i"));
+		if (everyMatch) limitWindowMs = parseDurationMs(everyMatch[1]);
+	}
+	return new RateLimitError(provider, retryAfter, {
+		reason,
+		retryAfterMs,
+		limitWindowMs,
+		model: extra.model,
+		cause: error
+	});
+}
+function createRateLimitedAI(client, options) {
+	const config = normalizeRateLimitConfig(options);
+	if (!config) return client;
+	const wrappedMethods = /* @__PURE__ */ new Map();
+	const provider = typeof options.type === "string" && options.type ? options.type : "openai";
+	const clientTimeoutMs = positiveTimeout("timeout" in options ? options.timeout : void 0);
+	const allowSeevioSubmitRetry = options.type !== "seevio";
+	return new Proxy(client, { get(target, property, receiver) {
+		const value = Reflect.get(target, property, receiver);
+		if (typeof value !== "function") return value;
+		if (!RATE_LIMITED_METHODS.has(property)) {
+			if (!wrappedMethods.has(property)) wrappedMethods.set(property, value.bind(target));
+			return wrappedMethods.get(property);
+		}
+		if (!wrappedMethods.has(property)) {
+			const controlsIndex = REQUEST_CONTROLS_INDEX[property];
+			wrappedMethods.set(property, (...args) => {
+				const coordinator = getBudgetCoordinator(config.key);
+				const controls = controlsIndex === void 0 ? void 0 : args[controlsIndex];
+				const timeoutMs = controlsIndex === void 0 ? clientTimeoutMs : controls?.timeout !== void 0 ? positiveTimeout(controls.timeout) : clientTimeoutMs ?? 12e4;
+				const budget = {
+					provider,
+					timeoutMs,
+					deadline: timeoutMs === void 0 ? void 0 : Date.now() + timeoutMs,
+					signal: controls?.signal
+				};
+				return coordinator.schedule(() => invokeWithPacing((remainingMs) => {
+					const callArgs = [...args];
+					if (controlsIndex !== void 0 && remainingMs !== void 0) callArgs[controlsIndex] = {
+						...controls,
+						timeout: Math.max(1, Math.floor(remainingMs))
+					};
+					return Reflect.apply(value, target, callArgs);
+				}, coordinator, config, budget, property !== "submitVideoGenerationJob" || allowSeevioSubmitRetry), budget);
+			});
+		}
+		return wrappedMethods.get(property);
+	} });
+}
+/** A usable timeout, or undefined so the provider reports a bad value itself. */
+function positiveTimeout(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : void 0;
+}
+//#endregion
+export { DEFAULT_AI_TIMEOUT_MS as a, normalizeChatOptions as c, DEFAULT_AI_MAX_RETRIES as i, normalizeImageGenerationOptions as l, rateLimitErrorFrom as n, createObservedAI as o, DEFAULT_AI_GENERATION_LIMITS as r, normalizeBaseAIOptions as s, createRateLimitedAI as t, prepareRequestControls as u };
+
+//# sourceMappingURL=rate-limit-BzWfHA0e.js.map