| 'five_hour'

| 'seven_day'

| 'seven_day_opus'

| 'seven_day_sonnet'

rateLimitType: RateLimitType

claimAbbrev: '5h' | '7d'

windowSeconds: number

thresholds: EarlyWarningThreshold[]

const nowSeconds = Date.now() / 1000

const windowStart = resetsAt - windowSeconds

const elapsed = nowSeconds - windowStart

return Math.max(0, Math.min(1, elapsed / windowSeconds))

| 'overage_not_provisioned' // Overage is not provisioned for this org or seat tier

| 'org_level_disabled' // Organization doesn't have overage enabled

| 'org_level_disabled_until' // Organization overage temporarily disabled

| 'out_of_credits' // Organization has insufficient credits

| 'seat_tier_level_disabled' // Seat tier doesn't have overage enabled

| 'member_level_disabled' // Account specifically has overage disabled

| 'seat_tier_zero_credit_limit' // Seat tier has a zero credit limit

| 'group_zero_credit_limit' // Resolved group limit has a zero credit limit

| 'member_zero_credit_limit' // Account has a zero credit limit

| 'org_service_level_disabled' // Org service specifically has overage disabled

| 'org_service_zero_credit_limit' // Org service has a zero credit limit

| 'no_limits_configured' // No overage limits configured for account

status: QuotaStatus

// unifiedRateLimitFallbackAvailable is currently used to warn users that set

// their model to Opus whenever they are about to run out of quota. It does

// not change the actual model that is used.

unifiedRateLimitFallbackAvailable: boolean

resetsAt?: number

rateLimitType?: RateLimitType

utilization?: number

overageStatus?: QuotaStatus

overageResetsAt?: number

overageDisabledReason?: OverageDisabledReason

isUsingOverage?: boolean

surpassedThreshold?: number

const result: RawUtilization = {}

for (const [key, abbrev] of [

['five_hour', '5h'],

['seven_day', '7d'],

] as const) {

const util = headers.get(

`anthropic-ratelimit-unified-${abbrev}-utilization`,

)

const reset = headers.get(`anthropic-ratelimit-unified-${abbrev}-reset`)

if (util !== null && reset !== null) {

result[key] = { utilization: Number(util), resets_at: Number(reset) }

}

}

return result

currentLimits = limits

statusListeners.forEach(listener => listener(limits))

const hoursTillReset = Math.round(

(limits.resetsAt ? limits.resetsAt - Date.now() / 1000 : 0) / (60 * 60),

)

logEvent('tengu_claudeai_limits_status_changed', {

status:

limits.status as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,

unifiedRateLimitFallbackAvailable: limits.unifiedRateLimitFallbackAvailable,

hoursTillReset,

})

const model = getSmallFastModel()

const anthropic = await getAnthropicClient({

maxRetries: 0,

model,

source: 'quota_check',

})

const messages: MessageParam[] = [{ role: 'user', content: 'quota' }]

const betas = getModelBetas(model)

// biome-ignore lint/plugin: quota check needs raw response access via asResponse()

return anthropic.beta.messages

.create({

model,

max_tokens: 1,

messages,

metadata: getAPIMetadata(),

...(betas.length > 0 ? { betas } : {}),

})

.asResponse()

// Skip network requests if nonessential traffic is disabled

if (isEssentialTrafficOnly()) {

return

}

// Check if we should process rate limits (real subscriber or mock testing)

if (!shouldProcessRateLimits(isClaudeAISubscriber())) {

return

}

// In non-interactive mode (-p), the real query follows immediately and

// extractQuotaStatusFromHeaders() will update limits from its response

// headers (claude.ts), so skip this pre-check API call.

if (getIsNonInteractiveSession()) {

return

}

try {

// Make a minimal request to check quota

const raw = await makeTestQuery()

// Update limits based on the response

extractQuotaStatusFromHeaders(raw.headers)

} catch (error) {

if (error instanceof APIError) {

extractQuotaStatusFromError(error)

}

}

headers: globalThis.Headers,

unifiedRateLimitFallbackAvailable: boolean,

): ClaudeAILimits | null {

// Check each claim type for surpassed threshold header

for (const [claimAbbrev, rateLimitType] of Object.entries(

EARLY_WARNING_CLAIM_MAP,

)) {

const surpassedThreshold = headers.get(

`anthropic-ratelimit-unified-${claimAbbrev}-surpassed-threshold`,

)

// If threshold header is present, user has crossed a warning threshold

if (surpassedThreshold !== null) {

const utilizationHeader = headers.get(

`anthropic-ratelimit-unified-${claimAbbrev}-utilization`,

)

const resetHeader = headers.get(

`anthropic-ratelimit-unified-${claimAbbrev}-reset`,

)

const utilization = utilizationHeader

? Number(utilizationHeader)

: undefined

const resetsAt = resetHeader ? Number(resetHeader) : undefined

return {

status: 'allowed_warning',

resetsAt,

rateLimitType: rateLimitType as RateLimitType,

utilization,

unifiedRateLimitFallbackAvailable,

isUsingOverage: false,

surpassedThreshold: Number(surpassedThreshold),

}

}

}

return null

headers: globalThis.Headers,

config: EarlyWarningConfig,

unifiedRateLimitFallbackAvailable: boolean,

): ClaudeAILimits | null {

const { rateLimitType, claimAbbrev, windowSeconds, thresholds } = config

const utilizationHeader = headers.get(

`anthropic-ratelimit-unified-${claimAbbrev}-utilization`,

)

const resetHeader = headers.get(

`anthropic-ratelimit-unified-${claimAbbrev}-reset`,

)

if (utilizationHeader === null || resetHeader === null) {

return null

}

const utilization = Number(utilizationHeader)

const resetsAt = Number(resetHeader)

const timeProgress = computeTimeProgress(resetsAt, windowSeconds)

// Check if any threshold is exceeded: high usage early in the window

const shouldWarn = thresholds.some(

t => utilization >= t.utilization && timeProgress <= t.timePct,

)

if (!shouldWarn) {

return null

}

return {

status: 'allowed_warning',

resetsAt,

rateLimitType,

utilization,

unifiedRateLimitFallbackAvailable,

isUsingOverage: false,

}

headers: globalThis.Headers,

unifiedRateLimitFallbackAvailable: boolean,

): ClaudeAILimits | null {

// Try header-based detection first (preferred when API sends the header)

const headerBasedWarning = getHeaderBasedEarlyWarning(

headers,

unifiedRateLimitFallbackAvailable,

)

if (headerBasedWarning) {

return headerBasedWarning

}

// Fallback: Use time-relative thresholds (client-side calculation)

// This catches users burning quota faster than sustainable

for (const config of EARLY_WARNING_CONFIGS) {

const timeRelativeWarning = getTimeRelativeEarlyWarning(

headers,

config,

unifiedRateLimitFallbackAvailable,

)

if (timeRelativeWarning) {

return timeRelativeWarning

}

}

return null

headers: globalThis.Headers,

): ClaudeAILimits {

const status =

(headers.get('anthropic-ratelimit-unified-status') as QuotaStatus) ||

'allowed'

const resetsAtHeader = headers.get('anthropic-ratelimit-unified-reset')

const resetsAt = resetsAtHeader ? Number(resetsAtHeader) : undefined

const unifiedRateLimitFallbackAvailable =

headers.get('anthropic-ratelimit-unified-fallback') === 'available'

// Headers for rate limit type and overage support

const rateLimitType = headers.get(

'anthropic-ratelimit-unified-representative-claim',

) as RateLimitType | null

const overageStatus = headers.get(

'anthropic-ratelimit-unified-overage-status',

) as QuotaStatus | null

const overageResetsAtHeader = headers.get(

'anthropic-ratelimit-unified-overage-reset',

)

const overageResetsAt = overageResetsAtHeader

? Number(overageResetsAtHeader)

: undefined

// Reason why overage is disabled (spending cap or wallet empty)

const overageDisabledReason = headers.get(

'anthropic-ratelimit-unified-overage-disabled-reason',

) as OverageDisabledReason | null

// Determine if we're using overage (standard limits rejected but overage allowed)

const isUsingOverage =

status === 'rejected' &&

(overageStatus === 'allowed' || overageStatus === 'allowed_warning')

// Check for early warning based on surpassed-threshold header

// If status is allowed/allowed_warning and we find a surpassed threshold, show warning

let finalStatus: QuotaStatus = status

if (status === 'allowed' || status === 'allowed_warning') {

const earlyWarning = getEarlyWarningFromHeaders(

headers,

unifiedRateLimitFallbackAvailable,

)

if (earlyWarning) {

return earlyWarning

}

// No early warning threshold surpassed

finalStatus = 'allowed'

}

return {

status: finalStatus,

resetsAt,

unifiedRateLimitFallbackAvailable,

...(rateLimitType && { rateLimitType }),

...(overageStatus && { overageStatus }),

...(overageResetsAt && { overageResetsAt }),

...(overageDisabledReason && { overageDisabledReason }),

isUsingOverage,

}

// A null reason means extra usage is enabled (no disabled reason header)

const reason =

headers.get('anthropic-ratelimit-unified-overage-disabled-reason') ?? null

const cached = getGlobalConfig().cachedExtraUsageDisabledReason

if (cached !== reason) {

saveGlobalConfig(current => ({

...current,

cachedExtraUsageDisabledReason: reason,

}))

}

headers: globalThis.Headers,

): void {

// Check if we need to process rate limits

const isSubscriber = isClaudeAISubscriber()

if (!shouldProcessRateLimits(isSubscriber)) {

// If we have any rate limit state, clear it

rawUtilization = {}

if (currentLimits.status !== 'allowed' || currentLimits.resetsAt) {

const defaultLimits: ClaudeAILimits = {

status: 'allowed',

unifiedRateLimitFallbackAvailable: false,

isUsingOverage: false,

}

emitStatusChange(defaultLimits)

}

return

}

// Process headers (applies mocks from /mock-limits command if active)

const headersToUse = processRateLimitHeaders(headers)

rawUtilization = extractRawUtilization(headersToUse)

const newLimits = computeNewLimitsFromHeaders(headersToUse)

// Cache extra usage status (persists across sessions)

cacheExtraUsageDisabledReason(headersToUse)

if (!isEqual(currentLimits, newLimits)) {

emitStatusChange(newLimits)

}

if (

!shouldProcessRateLimits(isClaudeAISubscriber()) ||

error.status !== 429

) {

return

}

try {

let newLimits = { ...currentLimits }

if (error.headers) {

// Process headers (applies mocks from /mock-limits command if active)

const headersToUse = processRateLimitHeaders(error.headers)

rawUtilization = extractRawUtilization(headersToUse)

newLimits = computeNewLimitsFromHeaders(headersToUse)

// Cache extra usage status (persists across sessions)

cacheExtraUsageDisabledReason(headersToUse)

}

// For errors, always set status to rejected even if headers are not present.

newLimits.status = 'rejected'

if (!isEqual(currentLimits, newLimits)) {

emitStatusChange(newLimits)

}

} catch (e) {

logError(e as Error)

}