Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

7.1 KB
Raw Blame
package access

import (
	"errors"
	"fmt"
	"math"
	"slices"
	"time"
)

// Limit is a gateway key's budget for a window: a calendar one in local
// time (#585), a day from midnight, a week from Monday's midnight, a
// month from the 1st's; or a cycle of Days days (#1509, period "days")
// or of Hours hours (#2102, period "hours", a subscription's 5-hour
// window's pace), the first from when the limit was set, each next one a
// cycle after the last. Tokens counts each call's uncached input, output (reasoning
// included) and cache writes, and its cache reads too when CacheReads is
// set; Cost is an estimate in US dollars at the prices magpie shows on
// the Usage page, not a vendor's bill. A cap of 0 is no cap; a limit with
// neither is no limit.
type Limit struct {
	Period string `json:"period"`
	// Days is a "days" limit's cycle, 1 to MaxDays; 0 for the others.
	Days int `json:"days,omitempty"`
	// Hours is an "hours" limit's cycle, 1 to MaxHours; 0 for the others.
	Hours      int     `json:"hours,omitempty"`
	Tokens     int64   `json:"tokens,omitempty"`
	Cost       float64 `json:"cost,omitempty"`
	CacheReads bool    `json:"cacheReads,omitempty"`
	// Since is magpie's, never the caller's (Update sets it): for "days"
	// and "hours", when the first cycle began, the limit set or last reset; for a
	// calendar period, when it was last reset, so a call before it in
	// the same window doesn't count. Zero for a calendar limit never
	// reset, as every limit from before #1509 is.
	Since time.Time `json:"since,omitzero"`
}

// MaxLimits is how many limits one key can have (#2227).
const MaxLimits = 5

// Limits are k's limits, its Limit first; none for a key with no limit.
// Each holds the key on its own: a request passes only while all of them
// have something left.
func (k Key) Limits() []*Limit { return limitsOf(k.Limit, k.More) }

// Limits are the limits who's key holds it to, as Key.Limits.
func (who Identity) Limits() []*Limit { return limitsOf(who.Limit, who.More) }

func limitsOf(first *Limit, more []Limit) []*Limit {
	var out []*Limit
	if first.Limited() {
		out = append(out, first)
	}
	for i := range more {
		if more[i].Limited() {
			out = append(out, &more[i])
		}
	}
	return out
}

// limitList is a copy of k's limits, to change and set back.
func (k *Key) limitList() []Limit {
	var out []Limit
	for _, l := range k.Limits() {
		out = append(out, *l)
	}
	return out
}

// setLimits keeps ls as k's limits: the first as Limit, so a magpie from
// before #2227 still holds the key to it, the rest as More.
func (k *Key) setLimits(ls []Limit) {
	k.Limit, k.More = nil, nil
	if len(ls) > 0 {
		first := ls[0]
		k.Limit = &first
		k.More = slices.Clone(ls[1:])
	}
	if len(k.More) == 0 {
		k.More = nil
	}
}

// sameWindow: l and o count in the same window, so two limits of one key
// that do are one limit with two caps.
func (l *Limit) sameWindow(o *Limit) bool {
	return l.Period == o.Period && l.Days == o.Days && l.Hours == o.Hours
}

// Periods are the windows a limit can be set for.
var Periods = []string{"day", "week", "month", "days", "hours"}

// MaxDays is the longest "days" cycle, ten years.
const MaxDays = 3650

// MaxHours is the longest "hours" cycle, a year; a longer one is a
// "days" cycle.
const MaxHours = 8760

// cycle is a "days" or "hours" limit's cycle, 0 for a calendar one.
func (l *Limit) cycle() time.Duration {
	switch l.Period {
	case "days":
		return time.Duration(min(max(l.Days, 1), MaxDays)) * 24 * time.Hour
	case "hours":
		return time.Duration(min(max(l.Hours, 1), MaxHours)) * time.Hour
	}
	return 0
}

// Limited: l caps something.
func (l *Limit) Limited() bool { return l != nil && (l.Tokens > 0 || l.Cost > 0) }

// Valid is l as it is kept: nil for no limit, an error for one that
// can't be. Since is left as it came; Update decides it.
func (l *Limit) Valid() (*Limit, error) {
	if l == nil {
		return nil, nil
	}
	if l.Tokens < 0 || l.Cost < 0 || math.IsNaN(l.Cost) || math.IsInf(l.Cost, 0) {
		return nil, errors.New("A limit can't be negative")
	}
	if !l.Limited() {
		return nil, nil
	}
	v := *l
	if v.Period == "" {
		v.Period = "day"
	}
	switch v.Period {
	case "day", "week", "month":
		v.Days, v.Hours = 0, 0
	case "days":
		v.Hours = 0
		if v.Days < 1 || v.Days > MaxDays {
			return nil, fmt.Errorf("A limit's cycle is a whole number of days from 1 to %d", MaxDays)
		}
	case "hours":
		v.Days = 0
		if v.Hours < 1 || v.Hours > MaxHours {
			return nil, fmt.Errorf("A limit's cycle is a whole number of hours from 1 to %d", MaxHours)
		}
	default:
		return nil, errors.New("A limit's period is day, week, month, every N days or every N hours")
	}
	v.Cost = math.Round(v.Cost*1e4) / 1e4
	return &v, nil
}

// Per is the window as a sentence ends it: "day", "week", "month",
// "10-day cycle" or "5-hour cycle".
func (l *Limit) Per() string {
	switch l.Period {
	case "days":
		return fmt.Sprintf("%d-day cycle", l.Days)
	case "hours":
		return fmt.Sprintf("%d-hour cycle", l.Hours)
	}
	return l.Period
}

// sinceOf is the Since a limit set as next keeps, with prev the key's
// limit before: its own while the period and cycle stay the same (a new
// cap doesn't restart the window), else a new cycle from now for "days"
// and "hours", and none for a calendar period.
func sinceOf(prev, next *Limit, now time.Time) time.Time {
	cyclic := next.cycle() > 0
	if prev != nil && prev.Period == next.Period && prev.Days == next.Days && prev.Hours == next.Hours && (!cyclic || !prev.Since.IsZero()) {
		return prev.Since
	}
	if cyclic {
		return now
	}
	return time.Time{}
}

// epoch is where a cycle written by hand without a Since runs from.
var epoch = time.Unix(0, 0)

// Window is the window l counts in at now, in now's location: when it
// began and when the next begins. A "days" or "hours" cycle is counted
// in absolute time, 24h a day whatever the clocks do, so a restart or a change of
// time zone or summer time keeps it; one with no Since runs from the Unix
// epoch. A calendar window starts at Since instead when the key was reset
// in it.
func (l *Limit) Window(now time.Time) (start, reset time.Time) {
	loc := now.Location()
	if n := l.cycle(); n > 0 {
		anchor := l.Since
		if anchor.Before(epoch) {
			anchor = epoch
		}
		if now.Before(anchor) { // the clock was set back past the start
			return anchor.In(loc), anchor.Add(n).In(loc)
		}
		start = anchor.Add(now.Sub(anchor) / n * n)
		return start.In(loc), start.Add(n).In(loc)
	}
	start, reset = Window(l.Period, now)
	if l.Since.After(start) && l.Since.Before(reset) {
		start = l.Since.In(loc)
	}
	return start, reset
}

// Window is the calendar window of period that now is in, in now's
// location: its start and when the next begins.
func Window(period string, now time.Time) (start, reset time.Time) {
	y, m, d := now.Date()
	loc := now.Location()
	switch period {
	case "week":
		back := (int(now.Weekday()) + 6) % 7 // days since Monday
		start = time.Date(y, m, d-back, 0, 0, 0, 0, loc)
		return start, time.Date(y, m, d-back+7, 0, 0, 0, 0, loc)
	case "month":
		return time.Date(y, m, 1, 0, 0, 0, 0, loc), time.Date(y, m+1, 1, 0, 0, 0, 0, loc)
	default:
		return time.Date(y, m, d, 0, 0, 0, 0, loc), time.Date(y, m, d+1, 0, 0, 0, 0, loc)
	}
}