@jsonstudio/llms 0.6.1449 → 0.6.1643

package/dist/quota/quota-manager.js

@@ -0,0 +1,491 @@
+import { computeNextDailyResetAtMs } from './apikey-reset.js';
+import { applyErrorEvent, applySuccessEvent, createInitialQuotaState, tickQuotaStateTime } from './quota-state.js';
+function safeTrim(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function readEnvDurationMs(envKey, fallbackMs) {
+    const raw = String(process.env[envKey] ?? '').trim();
+    if (!raw)
+        return fallbackMs;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return fallbackMs;
+    return Math.floor(n);
+}
+const ANTIGRAVITY_AUTH_VERIFY_BAN_MS = readEnvDurationMs('ROUTECODEX_ANTIGRAVITY_AUTH_VERIFY_BAN', 24 * 60 * 60_000);
+const ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS = readEnvDurationMs('ROUTECODEX_ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN', 5 * 60_000);
+function parseProviderKey(ev) {
+    const key = safeTrim(ev?.providerKey);
+    return key;
+}
+function parseHttpStatus(ev) {
+    const status = ev?.status;
+    if (typeof status === 'number' && Number.isFinite(status)) {
+        return status;
+    }
+    const runtime = ev?.runtime;
+    const maybe = runtime && typeof runtime === 'object' ? runtime.status : null;
+    if (typeof maybe === 'number' && Number.isFinite(maybe)) {
+        return maybe;
+    }
+    return null;
+}
+function extractResetAtIso(details) {
+    if (!details || typeof details !== 'object') {
+        return null;
+    }
+    const v = details.resetAt;
+    const raw = typeof v === 'string' ? v.trim() : '';
+    if (raw) {
+        return raw;
+    }
+    const meta = details.meta && typeof details.meta === 'object' && !Array.isArray(details.meta)
+        ? details.meta
+        : null;
+    const metaResetAt = meta && typeof meta.resetAt === 'string' ? String(meta.resetAt).trim() : '';
+    if (metaResetAt) {
+        return metaResetAt;
+    }
+    return null;
+}
+function extractResetAtIsoFromText(text) {
+    const raw = typeof text === 'string' ? text.trim() : '';
+    if (!raw) {
+        return null;
+    }
+    // Try to parse an embedded JSON payload (common in provider error messages).
+    const firstBrace = raw.indexOf('{');
+    const lastBrace = raw.lastIndexOf('}');
+    if (firstBrace >= 0 && lastBrace > firstBrace) {
+        const jsonCandidate = raw.slice(firstBrace, lastBrace + 1);
+        try {
+            const parsed = JSON.parse(jsonCandidate);
+            const direct = parsed && typeof parsed.resetAt === 'string' ? String(parsed.resetAt).trim() : '';
+            if (direct) {
+                return direct;
+            }
+            const nested = parsed && parsed.error && typeof parsed.error === 'object' ? parsed.error : null;
+            const nestedResetAt = nested && typeof nested.resetAt === 'string' ? String(nested.resetAt).trim() : '';
+            if (nestedResetAt) {
+                return nestedResetAt;
+            }
+        }
+        catch {
+            // ignore JSON parse failures; fall back to regex matching
+        }
+    }
+    const m = raw.match(/"resetAt"\s*:\s*"([^"]+)"/i) ||
+        raw.match(/"reset_at"\s*:\s*"([^"]+)"/i) ||
+        raw.match(/resetAt\s*[:=]\s*"?([0-9]{4}-[0-9]{2}-[0-9]{2}T[^"\s]+)"?/i) ||
+        raw.match(/reset_at\s*[:=]\s*"?([0-9]{4}-[0-9]{2}-[0-9]{2}T[^"\s]+)"?/i);
+    const captured = m && typeof m[1] === 'string' ? m[1].trim() : '';
+    return captured ? captured : null;
+}
+function extractResetAtIsoFromSources(sources) {
+    for (const source of sources) {
+        const candidate = extractResetAtIsoFromText(source);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function collectUpstreamErrorSources(ev) {
+    const sources = [];
+    const msg = typeof ev.message === 'string' ? ev.message : '';
+    if (msg)
+        sources.push(msg);
+    const details = ev.details && typeof ev.details === 'object' && !Array.isArray(ev.details) ? ev.details : null;
+    if (details) {
+        const upstreamMessage = typeof details.upstreamMessage === 'string' ? details.upstreamMessage : '';
+        if (upstreamMessage && upstreamMessage.trim())
+            sources.push(upstreamMessage);
+        const meta = details.meta && typeof details.meta === 'object' && !Array.isArray(details.meta) ? details.meta : null;
+        if (meta) {
+            const metaUpstream = typeof meta.upstreamMessage === 'string' ? meta.upstreamMessage : '';
+            const metaMessage = typeof meta.message === 'string' ? meta.message : '';
+            if (metaUpstream && metaUpstream.trim())
+                sources.push(metaUpstream);
+            if (metaMessage && metaMessage.trim())
+                sources.push(metaMessage);
+        }
+    }
+    return sources;
+}
+function isAntigravityProviderKey(providerKey) {
+    return providerKey.toLowerCase().startsWith('antigravity.');
+}
+function resolveAntigravityRuntimeKey(providerKey, ev) {
+    const rtKey = safeTrim(ev?.runtime?.target?.runtimeKey);
+    if (rtKey)
+        return rtKey;
+    const parts = providerKey.split('.').filter(Boolean);
+    if (parts.length >= 2) {
+        return `${parts[0]}.${parts[1]}`;
+    }
+    return null;
+}
+function isGoogleAccountVerificationRequired(ev, sources) {
+    if (!sources.length) {
+        sources = collectUpstreamErrorSources(ev);
+    }
+    const lowered = sources.join(' | ').toLowerCase();
+    return (lowered.includes('verify your account') ||
+        lowered.includes('validation_required') ||
+        lowered.includes('validation required') ||
+        lowered.includes('validation_url') ||
+        lowered.includes('validation url') ||
+        lowered.includes('accounts.google.com/signin/continue') ||
+        lowered.includes('support.google.com/accounts?p=al_alert'));
+}
+function isThoughtSignatureMissing(ev, sources) {
+    const code = typeof ev.code === 'string' ? ev.code.trim().toLowerCase() : '';
+    if (code.includes('thought') && code.includes('signature')) {
+        return true;
+    }
+    if (!sources.length) {
+        sources = collectUpstreamErrorSources(ev);
+    }
+    for (const source of sources) {
+        const lowered = source.toLowerCase();
+        const mentionsSignature = lowered.includes('thoughtsignature') ||
+            lowered.includes('thought signature') ||
+            lowered.includes('reasoning_signature') ||
+            lowered.includes('reasoning signature');
+        if (!mentionsSignature)
+            continue;
+        if (lowered.includes('missing') ||
+            lowered.includes('required') ||
+            lowered.includes('invalid') ||
+            lowered.includes('not provided') ||
+            lowered.includes('签名') ||
+            lowered.includes('缺少') ||
+            lowered.includes('无效')) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractFirstUrl(sources) {
+    for (const source of sources) {
+        const m = String(source || '').match(/https?:\/\/\S+/);
+        if (m && m[0]) {
+            const url = m[0].replace(/[)\],.]+$/g, '');
+            return url || null;
+        }
+    }
+    return null;
+}
+export class QuotaManager {
+    staticConfigs = new Map();
+    states = new Map();
+    store;
+    persistTimer = null;
+    dirty = false;
+    constructor(options) {
+        this.store = options?.store ?? null;
+    }
+    async hydrateFromStore() {
+        if (!this.store) {
+            return;
+        }
+        const snapshot = await this.store.load().catch(() => null);
+        if (!snapshot || !snapshot.providers || typeof snapshot.providers !== 'object') {
+            return;
+        }
+        const nowMs = Date.now();
+        for (const [providerKey, raw] of Object.entries(snapshot.providers)) {
+            if (!raw || typeof raw !== 'object')
+                continue;
+            const key = safeTrim(providerKey) || safeTrim(raw.providerKey);
+            if (!key)
+                continue;
+            const state = raw;
+            this.states.set(key, tickQuotaStateTime({ ...state, providerKey: key }, nowMs));
+        }
+    }
+    registerProviderStaticConfig(providerKey, cfg) {
+        const key = safeTrim(providerKey);
+        if (!key)
+            return;
+        this.staticConfigs.set(key, { ...cfg });
+        if (!this.states.has(key)) {
+            this.states.set(key, createInitialQuotaState(key, cfg, Date.now()));
+            this.markDirty();
+        }
+    }
+    ensureProvider(providerKey) {
+        const key = safeTrim(providerKey);
+        if (!key) {
+            throw new Error('providerKey is required');
+        }
+        const existing = this.states.get(key);
+        if (existing) {
+            return existing;
+        }
+        const cfg = this.staticConfigs.get(key);
+        const seeded = createInitialQuotaState(key, cfg, Date.now());
+        this.states.set(key, seeded);
+        this.markDirty();
+        return seeded;
+    }
+    disableProvider(options) {
+        const key = safeTrim(options.providerKey);
+        if (!key)
+            return;
+        const nowMs = Date.now();
+        const state = this.ensureProvider(key);
+        const until = nowMs + Math.max(0, Math.floor(options.durationMs));
+        const next = options.mode === 'blacklist'
+            ? { ...state, blacklistUntil: Math.max(state.blacklistUntil ?? 0, until) || until, reason: 'blacklist', inPool: false }
+            : { ...state, cooldownUntil: Math.max(state.cooldownUntil ?? 0, until) || until, reason: 'cooldown', inPool: false };
+        this.states.set(key, tickQuotaStateTime(next, nowMs));
+        this.markDirty();
+    }
+    recoverProvider(providerKey) {
+        const key = safeTrim(providerKey);
+        if (!key)
+            return;
+        const nowMs = Date.now();
+        const state = this.ensureProvider(key);
+        const next = {
+            ...state,
+            cooldownUntil: null,
+            blacklistUntil: null,
+            authIssue: null,
+            reason: 'ok',
+            inPool: true
+        };
+        this.states.set(key, tickQuotaStateTime(next, nowMs));
+        this.markDirty();
+    }
+    resetProvider(providerKey) {
+        const key = safeTrim(providerKey);
+        if (!key)
+            return;
+        const nowMs = Date.now();
+        const cfg = this.staticConfigs.get(key);
+        this.states.set(key, createInitialQuotaState(key, cfg, nowMs));
+        this.markDirty();
+    }
+    onProviderError(ev) {
+        const providerKey = parseProviderKey(ev.runtime) || safeTrim(ev?.runtime?.providerKey) || safeTrim(ev?.providerKey);
+        if (!providerKey)
+            return;
+        const nowMs = typeof ev.timestamp === 'number' && Number.isFinite(ev.timestamp) ? ev.timestamp : Date.now();
+        const status = parseHttpStatus(ev);
+        const code = safeTrim(ev.code) || safeTrim(ev?.runtime?.errorCode);
+        const details = ev.details && typeof ev.details === 'object' ? ev.details : undefined;
+        const state = this.ensureProvider(providerKey);
+        // Antigravity account-scope auth verification required: blacklist the whole runtimeKey group.
+        if (isAntigravityProviderKey(providerKey)) {
+            const sources = collectUpstreamErrorSources(ev);
+            const runtimeKey = resolveAntigravityRuntimeKey(providerKey, ev);
+            if (runtimeKey && isGoogleAccountVerificationRequired(ev, sources)) {
+                const url = extractFirstUrl(sources);
+                const banUntil = nowMs + ANTIGRAVITY_AUTH_VERIFY_BAN_MS;
+                for (const key of this.states.keys()) {
+                    if (!key.startsWith(`${runtimeKey}.`))
+                        continue;
+                    const s = this.ensureProvider(key);
+                    const next = {
+                        ...s,
+                        inPool: false,
+                        reason: 'authVerify',
+                        authIssue: {
+                            kind: 'google_account_verification',
+                            ...(url ? { url } : {}),
+                            message: 'account verification required'
+                        },
+                        blacklistUntil: Math.max(s.blacklistUntil ?? 0, banUntil) || banUntil,
+                        cooldownUntil: null,
+                        lastErrorAtMs: nowMs,
+                        lastErrorCode: code || 'AUTH_VERIFY',
+                        lastErrorSeries: 'EFATAL',
+                        consecutiveErrorCount: 0
+                    };
+                    this.states.set(key, tickQuotaStateTime(next, nowMs));
+                }
+                this.markDirty();
+                return;
+            }
+            // Thought signature missing: freeze Gemini series under runtimeKey to avoid request storms.
+            if (isThoughtSignatureMissing(ev, sources)) {
+                const freezeUntil = nowMs + ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS;
+                const prefix = runtimeKey ? `${runtimeKey}.` : `${providerKey.split('.').slice(0, 2).join('.')}.`;
+                for (const key of this.states.keys()) {
+                    if (!key.startsWith(prefix))
+                        continue;
+                    const parts = key.split('.');
+                    const modelId = parts.length >= 3 ? parts.slice(2).join('.') : '';
+                    const lowerModel = modelId.toLowerCase();
+                    const isGeminiSeries = lowerModel.includes('gemini') && (lowerModel.includes('pro') || lowerModel.includes('flash'));
+                    if (!isGeminiSeries)
+                        continue;
+                    const s = this.ensureProvider(key);
+                    const next = {
+                        ...s,
+                        inPool: false,
+                        reason: 'cooldown',
+                        cooldownUntil: Math.max(s.cooldownUntil ?? 0, freezeUntil) || freezeUntil,
+                        lastErrorAtMs: nowMs,
+                        lastErrorCode: code || 'SIGNATURE_MISSING',
+                        lastErrorSeries: 'EOTHER',
+                        consecutiveErrorCount: 0
+                    };
+                    this.states.set(key, tickQuotaStateTime(next, nowMs));
+                }
+                this.markDirty();
+                return;
+            }
+        }
+        // HTTP 402: treat as quota depleted -> blacklist until reset.
+        if (status === 402 || code.toUpperCase() === 'HTTP_402') {
+            const resetAtIso = extractResetAtIso(details) ??
+                extractResetAtIsoFromSources(collectUpstreamErrorSources(ev));
+            let resetAtMs = null;
+            if (resetAtIso) {
+                const parsed = Date.parse(resetAtIso);
+                if (Number.isFinite(parsed) && parsed > nowMs) {
+                    resetAtMs = parsed;
+                }
+            }
+            if (resetAtMs === null) {
+                const staticCfg = this.staticConfigs.get(providerKey);
+                const configuredResetTime = staticCfg && typeof staticCfg.apikeyDailyResetTime === 'string'
+                    ? String(staticCfg.apikeyDailyResetTime).trim()
+                    : null;
+                resetAtMs = computeNextDailyResetAtMs({ nowMs, resetTime: configuredResetTime }).resetAtMs;
+            }
+            const next = {
+                ...state,
+                inPool: false,
+                reason: 'blacklist',
+                blacklistUntil: Math.max(state.blacklistUntil ?? 0, resetAtMs) || resetAtMs,
+                lastErrorAtMs: nowMs,
+                lastErrorCode: code || 'HTTP_402',
+                lastErrorSeries: 'EOTHER',
+                consecutiveErrorCount: 0
+            };
+            this.states.set(providerKey, tickQuotaStateTime(next, nowMs));
+            this.markDirty();
+            return;
+        }
+        const authIssue = details?.authIssue && typeof details.authIssue === 'object'
+            ? details.authIssue
+            : null;
+        const mapped = {
+            providerKey,
+            code: code || null,
+            httpStatus: typeof status === 'number' ? status : null,
+            fatal: Boolean(ev.recoverable === false || ev.affectsHealth === false ? false : ev?.fatal) || null,
+            timestampMs: nowMs,
+            resetAt: extractResetAtIso(details),
+            authIssue: authIssue || null
+        };
+        const next = applyErrorEvent(state, mapped, nowMs);
+        this.states.set(providerKey, tickQuotaStateTime(next, nowMs));
+        this.markDirty();
+    }
+    onProviderSuccess(ev) {
+        const providerKey = safeTrim(ev.runtime?.providerKey);
+        if (!providerKey)
+            return;
+        const nowMs = typeof ev.timestamp === 'number' && Number.isFinite(ev.timestamp) ? ev.timestamp : Date.now();
+        const state = this.ensureProvider(providerKey);
+        const mapped = { providerKey, timestampMs: nowMs };
+        const next = applySuccessEvent(state, mapped, nowMs);
+        this.states.set(providerKey, next);
+        this.markDirty();
+    }
+    /**
+     * External quota snapshot ingestion hook (host-driven).
+     * This API is intentionally small: the host adapter translates provider-specific
+     * quota responses into a normalized per-providerKey inPool/cooldown/blacklist update.
+     */
+    updateProviderPoolState(options) {
+        const key = safeTrim(options.providerKey);
+        if (!key)
+            return;
+        const nowMs = Date.now();
+        const state = this.ensureProvider(key);
+        const next = {
+            ...state,
+            inPool: Boolean(options.inPool),
+            reason: options.inPool ? 'ok' : state.reason,
+            cooldownUntil: typeof options.cooldownUntil === 'number' ? options.cooldownUntil : state.cooldownUntil,
+            blacklistUntil: typeof options.blacklistUntil === 'number' ? options.blacklistUntil : state.blacklistUntil,
+            ...(typeof options.reason === 'string' && options.reason.trim()
+                ? { reason: options.reason.trim() }
+                : {})
+        };
+        this.states.set(key, tickQuotaStateTime(next, nowMs));
+        this.markDirty();
+    }
+    getQuotaView() {
+        return (providerKey) => {
+            const key = safeTrim(providerKey);
+            if (!key)
+                return null;
+            const nowMs = Date.now();
+            const state = this.states.get(key);
+            if (!state) {
+                return null;
+            }
+            const normalized = tickQuotaStateTime(state, nowMs);
+            if (normalized !== state) {
+                this.states.set(key, normalized);
+            }
+            const withinBlacklist = typeof normalized.blacklistUntil === 'number' && normalized.blacklistUntil > nowMs;
+            const withinCooldown = typeof normalized.cooldownUntil === 'number' && normalized.cooldownUntil > nowMs;
+            const inPool = normalized.inPool && !withinBlacklist && !withinCooldown;
+            const hasRecentError = typeof normalized.lastErrorAtMs === 'number' &&
+                Number.isFinite(normalized.lastErrorAtMs) &&
+                nowMs - normalized.lastErrorAtMs >= 0 &&
+                nowMs - normalized.lastErrorAtMs <= 30_000;
+            const selectionPenalty = hasRecentError && typeof normalized.consecutiveErrorCount === 'number' && normalized.consecutiveErrorCount > 0
+                ? Math.max(0, Math.floor(normalized.consecutiveErrorCount))
+                : 0;
+            return {
+                providerKey: key,
+                inPool,
+                reason: normalized.reason,
+                priorityTier: normalized.priorityTier,
+                selectionPenalty,
+                lastErrorAtMs: normalized.lastErrorAtMs,
+                consecutiveErrorCount: normalized.consecutiveErrorCount,
+                cooldownUntil: normalized.cooldownUntil,
+                blacklistUntil: normalized.blacklistUntil
+            };
+        };
+    }
+    getSnapshot() {
+        return {
+            updatedAtMs: Date.now(),
+            providers: Object.fromEntries(this.states.entries())
+        };
+    }
+    markDirty() {
+        this.dirty = true;
+        if (this.persistTimer) {
+            return;
+        }
+        // best-effort debounce
+        this.persistTimer = setTimeout(() => {
+            this.persistTimer = null;
+            if (!this.dirty)
+                return;
+            this.dirty = false;
+            void this.persistNow();
+        }, 800);
+    }
+    async persistNow() {
+        if (!this.store)
+            return;
+        const snapshot = this.getSnapshot();
+        const payload = { savedAtMs: snapshot.updatedAtMs, providers: snapshot.providers };
+        await this.store.save(payload).catch(() => {
+            // persistence must never block routing
+        });
+    }
+}

package/dist/quota/quota-state.d.ts

@@ -0,0 +1,6 @@
+import type { ErrorEventForQuota, ErrorSeries, QuotaState, StaticQuotaConfig, SuccessEventForQuota } from './types.js';
+export declare function createInitialQuotaState(providerKey: string, staticConfig?: StaticQuotaConfig, nowMs?: number): QuotaState;
+export declare function normalizeErrorSeries(event: ErrorEventForQuota): ErrorSeries;
+export declare function tickQuotaStateTime(state: QuotaState, nowMs: number): QuotaState;
+export declare function applyErrorEvent(state: QuotaState, event: ErrorEventForQuota, nowMs?: number): QuotaState;
+export declare function applySuccessEvent(state: QuotaState, _event: SuccessEventForQuota, nowMs?: number): QuotaState;

package/dist/quota/quota-state.js

@@ -0,0 +1,167 @@
+const COOLDOWN_SCHEDULE_429_MS = [5_000, 30_000, 60_000, 300_000, 1_800_000, 3_600_000, 10_000_000];
+const COOLDOWN_SCHEDULE_FATAL_MS = [5 * 60_000, 15 * 60_000, 30 * 60_000, 60 * 60_000, 3 * 60 * 60_000];
+const COOLDOWN_SCHEDULE_DEFAULT_MS = [5_000, 30_000, 60_000, 300_000, 1_800_000, 3_600_000, 10_000_000];
+const ERROR_CHAIN_WINDOW_MS = 10 * 60_000;
+const NETWORK_ERROR_CODES = [
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'EAI_AGAIN',
+    'UPSTREAM_HEADERS_TIMEOUT',
+    'UPSTREAM_STREAM_TIMEOUT',
+    'UPSTREAM_STREAM_IDLE_TIMEOUT',
+    'UPSTREAM_STREAM_ABORTED'
+];
+export function createInitialQuotaState(providerKey, staticConfig, nowMs = Date.now()) {
+    const priorityTier = staticConfig && typeof staticConfig.priorityTier === 'number'
+        ? staticConfig.priorityTier
+        : 100;
+    const authType = staticConfig && typeof staticConfig.authType === 'string' && staticConfig.authType.trim()
+        ? staticConfig.authType.trim()
+        : 'unknown';
+    return {
+        providerKey,
+        inPool: true,
+        reason: 'ok',
+        authType,
+        authIssue: null,
+        priorityTier,
+        cooldownUntil: null,
+        blacklistUntil: null,
+        lastErrorSeries: null,
+        lastErrorCode: null,
+        lastErrorAtMs: null,
+        consecutiveErrorCount: 0
+    };
+}
+export function normalizeErrorSeries(event) {
+    if (event.fatal) {
+        return 'EFATAL';
+    }
+    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
+    const rawCode = String(event.code || '').toUpperCase();
+    if (status === 429 || rawCode.includes('429') || rawCode.includes('RATE') || rawCode.includes('QUOTA')) {
+        return 'E429';
+    }
+    if (status && status >= 500) {
+        return 'E5XX';
+    }
+    if (rawCode.includes('TIMEOUT') || NETWORK_ERROR_CODES.some((code) => rawCode.includes(code))) {
+        return 'ENET';
+    }
+    if (rawCode.includes('AUTH') || rawCode.includes('UNAUTHORIZED') || rawCode.includes('CONFIG') || rawCode.includes('FATAL')) {
+        return 'EFATAL';
+    }
+    return 'EOTHER';
+}
+function normalizeErrorKey(event) {
+    const rawCode = String(event.code || '').trim().toUpperCase();
+    if (rawCode) {
+        return rawCode;
+    }
+    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
+    if (status && Number.isFinite(status)) {
+        return `HTTP_${Math.floor(status)}`;
+    }
+    return 'ERR_UNKNOWN';
+}
+function computeCooldownMsBySeries(series, consecutive) {
+    if (consecutive <= 0) {
+        return null;
+    }
+    const schedule = series === 'E429'
+        ? COOLDOWN_SCHEDULE_429_MS
+        : series === 'EFATAL'
+            ? COOLDOWN_SCHEDULE_FATAL_MS
+            : COOLDOWN_SCHEDULE_DEFAULT_MS;
+    const idx = Math.min(consecutive - 1, schedule.length - 1);
+    return schedule[idx] ?? null;
+}
+export function tickQuotaStateTime(state, nowMs) {
+    let next = state;
+    if (typeof next.cooldownUntil === 'number' && next.cooldownUntil <= nowMs) {
+        next = { ...next, cooldownUntil: null };
+    }
+    if (typeof next.blacklistUntil === 'number' && next.blacklistUntil <= nowMs) {
+        next = { ...next, blacklistUntil: null };
+    }
+    if (next.authIssue) {
+        if (next.inPool !== false || next.reason !== 'authVerify') {
+            next = { ...next, inPool: false, reason: 'authVerify' };
+        }
+        return next;
+    }
+    const inCooldown = typeof next.cooldownUntil === 'number' && next.cooldownUntil > nowMs;
+    const inBlacklist = typeof next.blacklistUntil === 'number' && next.blacklistUntil > nowMs;
+    if (inBlacklist) {
+        if (next.inPool !== false || next.reason !== 'blacklist') {
+            next = { ...next, inPool: false, reason: 'blacklist' };
+        }
+        return next;
+    }
+    if (inCooldown) {
+        if (next.inPool !== false || next.reason !== 'cooldown') {
+            next = { ...next, inPool: false, reason: 'cooldown' };
+        }
+        return next;
+    }
+    // TTLs expired: only auto-reset "cooldown/blacklist" back to ok.
+    if (next.reason === 'cooldown' || next.reason === 'blacklist') {
+        next = { ...next, inPool: true, reason: 'ok' };
+    }
+    return next;
+}
+export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.now()) {
+    // Manual/operator blacklist is rigid: automated error events must not override it.
+    if (state.blacklistUntil !== null && nowMs < state.blacklistUntil) {
+        return state;
+    }
+    const series = normalizeErrorSeries(event);
+    const errorKey = normalizeErrorKey(event);
+    const lastAt = typeof state.lastErrorAtMs === 'number' && Number.isFinite(state.lastErrorAtMs)
+        ? state.lastErrorAtMs
+        : null;
+    const withinChainWindow = typeof lastAt === 'number' &&
+        nowMs - lastAt >= 0 &&
+        nowMs - lastAt <= ERROR_CHAIN_WINDOW_MS;
+    const sameErrorKey = withinChainWindow && state.lastErrorCode === errorKey;
+    const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
+    const schedule = series === 'E429'
+        ? COOLDOWN_SCHEDULE_429_MS
+        : series === 'EFATAL'
+            ? COOLDOWN_SCHEDULE_FATAL_MS
+            : COOLDOWN_SCHEDULE_DEFAULT_MS;
+    const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
+    const cooldownMs = computeCooldownMsBySeries(series, nextCount);
+    const nextUntil = cooldownMs ? nowMs + cooldownMs : null;
+    const existingUntil = typeof state.cooldownUntil === 'number' ? state.cooldownUntil : null;
+    const cooldownUntil = typeof nextUntil === 'number' && Number.isFinite(nextUntil)
+        ? typeof existingUntil === 'number' && existingUntil > nextUntil
+            ? existingUntil
+            : nextUntil
+        : existingUntil;
+    const inCooldown = typeof cooldownUntil === 'number' && cooldownUntil > nowMs;
+    const inBlacklist = typeof state.blacklistUntil === 'number' && state.blacklistUntil > nowMs;
+    const inPool = !inCooldown && !inBlacklist;
+    return {
+        ...state,
+        inPool,
+        reason: inBlacklist ? 'blacklist' : inCooldown ? 'cooldown' : 'ok',
+        cooldownUntil,
+        lastErrorSeries: series,
+        lastErrorCode: errorKey,
+        lastErrorAtMs: nowMs,
+        consecutiveErrorCount: nextCount,
+        ...(event.authIssue ? { authIssue: event.authIssue, reason: 'authVerify', inPool: false } : {})
+    };
+}
+export function applySuccessEvent(state, _event, nowMs = _event.timestampMs ?? Date.now()) {
+    const next = {
+        ...state,
+        lastErrorSeries: null,
+        lastErrorCode: null,
+        lastErrorAtMs: null,
+        consecutiveErrorCount: 0
+    };
+    return tickQuotaStateTime(next, nowMs);
+}