vercel-labs/agent-skills / skills/vercel-optimize
vercel-optimize
VerifiedUse for Vercel cost and performance optimization on deployed projects, especially Next.js, SvelteKit, Nuxt, and limited Astro apps. Collect Vercel metrics, usage, project config, and code scan results first; investigate only metric-backed candidates; produce ranked recommendations grounded in verified files and version-aware Vercel/framework docs. Trigger for Vercel bill reduction, slow or expensive routes, caching opportunities, Function Invocations, Build Minutes, Fast Data Transfer, Core Web Vitals, Bot Management, Fluid compute, or cost breakdown requests.
lib/throttle.mjs
View on GitHub// Zero-dependency concurrency + rate-limit primitives for `vercel metrics`. API cap is 100 req / 60s / team.
// CLI fails fast on 429 and doesn't surface Retry-After, so we back off blind.
const DEFAULT_CONCURRENCY = 8;
const DEFAULT_MAX_RETRIES = 3;
// Wait most of a 60s window when rate-limited — we don't know how much headroom remains. Jitter prevents lockstep retry.
const BASE_BACKOFF_MS = 60_000;
const JITTER_MS = 15_000;
// 20% headroom under the 100/60s cap for the user's other concurrent CLI usage.
const DEFAULT_RATE_LIMIT = 80;
const DEFAULT_RATE_WINDOW_MS = 60_000;
const DAILY_OBSERVABILITY_LIMIT_RE = /daily.*observability.*query limit/i;
let dailyQuotaBlock = null;
export function resolveConcurrency() {
return parsePositiveIntEnv('VERCEL_OPTIMIZE_METRIC_CONCURRENCY', DEFAULT_CONCURRENCY);
}
// Format: VERCEL_OPTIMIZE_METRIC_RATE=N or N/60s.
export function resolveRateLimit() {
const env = process.env.VERCEL_OPTIMIZE_METRIC_RATE;
if (env == null || env === '') return { maxCalls: DEFAULT_RATE_LIMIT, windowMs: DEFAULT_RATE_WINDOW_MS };
const m = String(env).trim().match(/^(\d+)(?:\/(\d+)([sm])?)?$/);
if (!m) return { maxCalls: DEFAULT_RATE_LIMIT, windowMs: DEFAULT_RATE_WINDOW_MS };
const maxCalls = Number(m[1]);
if (!Number.isInteger(maxCalls) || maxCalls < 1) {
return { maxCalls: DEFAULT_RATE_LIMIT, windowMs: DEFAULT_RATE_WINDOW_MS };
}
if (!m[2]) return { maxCalls, windowMs: DEFAULT_RATE_WINDOW_MS };
const unit = m[3] === 'm' ? 60_000 : 1_000;
const windowMs = Number(m[2]) * unit;
return { maxCalls, windowMs };
}
function parsePositiveIntEnv(name, defaultValue) {
const env = process.env[name];
if (env == null || env === '') return defaultValue;
const n = Number(env);
if (!Number.isFinite(n) || n < 1 || !Number.isInteger(n)) return defaultValue;
return n;
}
// FIFO semaphore. Caller MUST call returned release() exactly once.
export class SemaphoreAbortError extends Error {
constructor(result) {
super('Semaphore acquire aborted');
this.name = 'SemaphoreAbortError';
this.result = result;
}
}
export class Semaphore {
constructor(max) {
if (!Number.isInteger(max) || max < 1) {
throw new Error(`Semaphore: max must be a positive integer (got ${max})`);
}
this.max = max;
this.inFlight = 0;
this.waiters = [];
}
async acquire(opts = {}) {
const abortIf = opts.abortIf;
const preAbort = abortIf?.();
if (preAbort) throw new SemaphoreAbortError(preAbort);
if (this.inFlight < this.max) {
this.inFlight++;
return () => this.release();
}
await new Promise((resolve) => this.waiters.push(resolve));
const postAbort = abortIf?.();
if (postAbort) {
this.wakeNext();
throw new SemaphoreAbortError(postAbort);
}
this.inFlight++;
return () => this.release();
}
release() {
this.inFlight--;
this.wakeNext();
}
wakeNext() {
const next = this.waiters.shift();
if (next) next();
}
async run(fn, opts = {}) {
const release = await this.acquire(opts);
try {
return await fn();
} finally {
release();
}
}
}
// Load-bearing — semaphore alone is insufficient (8 concurrent × ~1s queries = 480/min, well above the 100/min cap).
export class SlidingWindowRateLimiter {
constructor(maxCalls, windowMs, opts = {}) {
if (!Number.isInteger(maxCalls) || maxCalls < 1) {
throw new Error(`SlidingWindowRateLimiter: maxCalls must be >=1 (got ${maxCalls})`);
}
if (!Number.isFinite(windowMs) || windowMs < 1) {
throw new Error(`SlidingWindowRateLimiter: windowMs must be >0 (got ${windowMs})`);
}
this.maxCalls = maxCalls;
this.windowMs = windowMs;
this.timestamps = []; // ascending order
this.now = opts.now ?? (() => Date.now());
this.sleep = opts.sleep ?? defaultSleep;
}
async acquire() {
while (true) {
this.prune();
if (this.timestamps.length < this.maxCalls) {
this.timestamps.push(this.now());
return;
}
// Small buffer avoids racing the window boundary.
const oldestExpiresAt = this.timestamps[0] + this.windowMs;
const sleepMs = Math.max(50, oldestExpiresAt - this.now() + 100);
await this.sleep(sleepMs);
}
}
prune() {
const cutoff = this.now() - this.windowMs;
while (this.timestamps.length > 0 && this.timestamps[0] < cutoff) {
this.timestamps.shift();
}
}
}
// Composes Semaphore + RateLimiter: bounds both burst (8 concurrent) and sustained throughput (80/60s).
let metricThrottleSingleton = null;
export function getMetricThrottle() {
if (!metricThrottleSingleton) {
const semaphore = new Semaphore(resolveConcurrency());
const { maxCalls, windowMs } = resolveRateLimit();
const rateLimiter = new SlidingWindowRateLimiter(maxCalls, windowMs);
metricThrottleSingleton = {
semaphore,
rateLimiter,
maxCalls,
windowMs,
async run(fn) {
const cached = getDailyQuotaBlock();
if (cached) return dailyQuotaResult(cached);
let release;
try {
release = await semaphore.acquire({ abortIf: () => {
const block = getDailyQuotaBlock();
return block ? dailyQuotaResult(block) : null;
} });
} catch (err) {
if (err instanceof SemaphoreAbortError) return err.result;
throw err;
}
try {
const afterAcquire = getDailyQuotaBlock();
if (afterAcquire) return dailyQuotaResult(afterAcquire);
await rateLimiter.acquire();
const result = await fn();
if (isDailyQuotaExceeded(result)) {
const block = setDailyQuotaBlocked(result);
return dailyQuotaResult(block, result);
}
return result;
} finally {
release();
}
},
};
}
return metricThrottleSingleton;
}
// Back-compat alias — returns the throttle object (compatible `.run(fn)` shape).
export const getMetricSemaphore = getMetricThrottle;
export function _resetMetricSemaphoreForTests() {
metricThrottleSingleton = null;
dailyQuotaBlock = null;
}
export async function retryOnRateLimit(fn, opts = {}) {
const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
const baseBackoffMs = opts.baseBackoffMs ?? BASE_BACKOFF_MS;
const jitterMs = opts.jitterMs ?? JITTER_MS;
const sleep = opts.sleep ?? defaultSleep;
const onRetry = opts.onRetry;
let attempt = 0;
while (true) {
const result = await fn();
if (!isRateLimited(result) || attempt >= maxRetries) return result;
attempt++;
// attempt 1 = 1x, 2 = 1.5x, 3 = 2x of base.
const factor = 1 + (attempt - 1) * 0.5;
const jitter = jitterMs > 0 ? Math.random() * jitterMs : 0;
const delay = Math.round(baseBackoffMs * factor + jitter);
if (onRetry) onRetry(attempt, delay, result);
await sleep(delay);
}
}
// Variants: code='RATE_LIMITED' (canonical), 'rate_limited', or 'EXIT_1' + stderr match.
export function isRateLimited(result) {
if (!result || result.ok !== false) return false;
const code = String(result.code ?? '').toLowerCase();
if (code === 'rate_limited' || code === '429') return true;
const stderr = String(result.stderr ?? '').toLowerCase();
if (stderr.includes('rate limit') || stderr.includes('rate_limited') || stderr.includes('too many requests')) {
return true;
}
return false;
}
export function isDailyQuotaExceeded(result) {
if (!result || result.ok !== false) return false;
const code = String(result.code ?? '');
if (code.toUpperCase() === 'DAILY_QUOTA_EXCEEDED') return true;
const haystack = [
result.message,
result.stderr,
result.stdout,
result.detail,
].filter(Boolean).join('\n');
return DAILY_OBSERVABILITY_LIMIT_RE.test(haystack);
}
export function setDailyQuotaBlocked(result, nowMs = Date.now()) {
dailyQuotaBlock = {
untilMs: utcMidnightAfter(nowMs),
originalCode: result?.code ?? null,
message: result?.message || result?.stderr || 'Daily Observability query limit reached.',
};
return dailyQuotaBlock;
}
export function getDailyQuotaBlock(nowMs = Date.now()) {
if (!dailyQuotaBlock) return null;
if (dailyQuotaBlock.untilMs <= nowMs) {
dailyQuotaBlock = null;
return null;
}
return dailyQuotaBlock;
}
export function utcMidnightAfter(nowMs) {
const d = new Date(nowMs);
return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + 1);
}
function dailyQuotaResult(block, sourceResult = null) {
return {
...(sourceResult && typeof sourceResult === 'object' ? sourceResult : {}),
ok: false,
code: 'DAILY_QUOTA_EXCEEDED',
message: block.message,
cachedUntil: new Date(block.untilMs).toISOString(),
originalCode: sourceResult?.originalCode ?? sourceResult?.code ?? block.originalCode ?? undefined,
};
}
function defaultSleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |