Skip to content

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

20.9 KB
Raw Blame
package provider

// How much of its allowance each of an agent's accounts has used, the one
// the agent is signed in to and every saved one, so picking which to use
// next is a look at the list, not a guess.

import (
	"context"
	"errors"
	"net/http"
	"strings"
	"sync"
	"time"

	"github.com/yetone/magpie/internal/settings"
)

var loginUsageCache struct {
	sync.Mutex
	m       map[string]loginUsageEntry // agent/user
	pending map[string]*loginRead      // agent/user: being read now
}

type loginUsageEntry struct {
	at time.Time
	q  SubscriptionQuota
	// read is the reading itself, as the Usage page shows it: q is the
	// same, but where a hiccup kept what was known
	read SubscriptionQuota
	// readAt, when set, is when read was really made: one handed back
	// held (allowances read only when asked) is dated now in at
	readAt time.Time
}

// readState is when an account's allowance was last read well, and
// whether the last try failed or was held back (a careful provider holds
// such an account: unknown is not spent, Provider.CapCareful).
type readState struct {
	at     time.Time
	failed bool
}

// state is what e says of the account's reading: a reading kept from
// before (AsOf) or one that failed counts as failed, as of the good one.
func (e loginUsageEntry) state() readState {
	at := e.at
	if !e.readAt.IsZero() {
		at = e.readAt
	}
	switch {
	case e.read.AsOf != nil:
		return readState{at: *e.read.AsOf, failed: true}
	case e.read.Error != "" || len(e.read.Windows) == 0:
		return readState{failed: true}
	}
	return readState{at: at}
}

// loginRead is an account's allowance being read: whoever asks for it
// meanwhile waits for it rather than asking the vendor again.
type loginRead struct {
	done chan struct{} // closed once e is in
	e    loginUsageEntry
}

// loginUsageFor, when set, stands in for LoginUsage's readings (tests),
// as UsageClaudeVia does for Claude's own. It is held for reading while it
// runs: Allowances reads in the background and returns without waiting,
// so a reading it began can outlast the test that set the stand-in.
var loginUsageFor struct {
	sync.RWMutex
	f func(ctx context.Context, agent string) map[string]SubscriptionQuota
}

// LoginUsageVia has tests stand in for LoginUsage's readings. It returns
// once no reading is still running through the one it replaces, and none
// starts through it after.
func LoginUsageVia(f func(ctx context.Context, agent string) map[string]SubscriptionQuota) {
	loginUsageFor.Lock()
	loginUsageFor.f = f
	loginUsageFor.Unlock()
}

// loginUsageStandIn is the stand-in's reading, and false when there is none.
func loginUsageStandIn(ctx context.Context, agent string) (map[string]SubscriptionQuota, bool) {
	loginUsageFor.RLock()
	defer loginUsageFor.RUnlock()
	if loginUsageFor.f == nil {
		return nil, false
	}
	return loginUsageFor.f(ctx, agent), true
}

// LoginUsage is the allowance used by each of an agent's accounts, by
// user. What was read less than a minute ago, here or for the Usage page,
// comes from the cache; the rest is asked for at once, as long as ctx
// allows.
func LoginUsage(ctx context.Context, agent string) map[string]SubscriptionQuota {
	out, _, _ := loginUsageAt(ctx, agent)
	return out
}

// loginUsageAt is LoginUsage and when the oldest of its readings was made:
// one taken from the cache is up to a minute old already, and Allowances
// counts its own minute from then, not from when it asked (#1295). And
// each account's reading's state: when it was last read well, and
// whether this try failed.
func loginUsageAt(ctx context.Context, agent string) (map[string]SubscriptionQuota, time.Time, map[string]readState) {
	return loginUsageOf(ctx, agent, nil)
}

// someLoginUsage is LoginUsage of the named accounts alone. What a
// background look needs is the account the agent is on, and the others
// only once that one is spent: reading every account at once, every few
// minutes from one address, is a pattern no single official client makes
// (owl on Discord, accounts held in magpie with no agent wired).
func someLoginUsage(ctx context.Context, agent string, users ...string) map[string]SubscriptionQuota {
	want := map[string]bool{}
	for _, u := range users {
		if u != "" {
			want[strings.ToLower(u)] = true
		}
	}
	if len(want) == 0 {
		return map[string]SubscriptionQuota{}
	}
	out, _, _ := loginUsageOf(ctx, agent, want)
	return out
}

// loginUsageOf is loginUsageAt over the accounts whose lower-cased user
// is in only, or over every account when only is nil.
func loginUsageOf(ctx context.Context, agent string, only map[string]bool) (map[string]SubscriptionQuota, time.Time, map[string]readState) {
	// nor of a provider switched off or removed (leftAlone)
	if settings.AccountDiscoveryOff() || leftAlone(agent) {
		return nil, time.Time{}, nil
	}
	asked := time.Now()
	states := map[string]readState{}
	if all, ok := loginUsageStandIn(ctx, agent); ok {
		out := all
		if only != nil {
			out = map[string]SubscriptionQuota{} // the stand-in's map is its own
			for user, q := range all {
				if only[strings.ToLower(user)] {
					out[user] = q
				}
			}
		}
		for user, q := range out {
			states[user] = loginUsageEntry{at: asked, read: q}.state()
		}
		return out, asked, states
	}
	out := map[string]SubscriptionQuota{}
	logins, ok := usageLogins(agent)
	if !ok {
		return out, asked, states
	}
	var mu sync.Mutex
	var wg sync.WaitGroup
	oldest := asked
	for _, l := range logins {
		if only != nil && !only[strings.ToLower(l.User)] {
			continue
		}
		wg.Add(1)
		go func() {
			defer wg.Done()
			e := loginReading(ctx, l)
			mu.Lock()
			out[l.User] = e.q
			states[l.User] = e.state()
			if e.q.Error == "" && e.at.Before(oldest) {
				oldest = e.at
			}
			mu.Unlock()
		}()
	}
	wg.Wait()
	usageRead(agent, out) // a window not started: the warm-up looks now
	if len(out) > 0 {
		// the batch's readings are points of each account's quota history
		// too, as a Usage-page reading is: a magpie only ever serving
		// other magpies has nobody on its Usage page, and its quota
		// history stayed empty otherwise (#1313). One note for the whole
		// batch: the file is read, parsed and written once for all
		// accounts. The note runs after every reading of the batch has
		// completed and released its in-flight marker, so no waiter on a
		// reading is held by a slow disk; the LoginUsage caller pays for
		// the write, and Allowances already calls it from its own
		// background goroutine. A detached goroutine is deliberately not
		// used: it would outlive the caller and write after tests and
		// commands have moved on (#1318 review). A cached reading notes
		// nothing new, its ReadAt no newer than what is kept; a failed
		// one is skipped.
		qs := make([]SubscriptionQuota, 0, len(out))
		for user, q := range out {
			q.User = user // a login's reading itself carries no user
			qs = append(qs, q)
		}
		noteHistory(qs, time.Now())
	}
	return out, oldest, states
}

// noteHistory notes a batch of accounts' readings in the quota history.
// The write is synchronous: it runs after the batch's readings have all
// completed, so it holds no waiter on a reading. Tests substitute their
// own note or write.
var noteHistory = func(qs []SubscriptionQuota, now time.Time) {
	noteHistoryWrite(qs, now)
}

// noteHistoryWrite is the history write itself; tests count or hold it.
var noteHistoryWrite = noteQuotaHistory

// loginReading is l's allowance as LoginUsage and the Usage page both show
// it, one reading for the two: what was read less than a minute ago comes
// from the cache, and an account being read is waited for, as long as ctx
// allows, rather than asked for again — the vendors' endpoints are
// rate limited, and two readings a moment apart told an account two ways.
func loginReading(ctx context.Context, l Login) loginUsageEntry {
	e := cachedLoginReading(ctx, l)
	if l.Agent == "codex" {
		// what magpie spent of its resets, as of now: a reading kept from
		// before one was spent still says it was
		used := ResetsUsed(l.User)
		e.q.ResetsUsed, e.read.ResetsUsed = used, used
	}
	return e
}

// cachedLoginReading is loginReading as read or kept.
func cachedLoginReading(ctx context.Context, l Login) loginUsageEntry {
	key := l.Agent + "/" + strings.ToLower(l.User)
	c := &loginUsageCache
	// with allowances read only when asked, one nobody asked for is what
	// was read last, however old, unless the vendor just turned the
	// account away for its quota (StaleAllowance), which is read (#1518)
	stale := false
	if holding(ctx) {
		if stale = isStaleRead(key); stale {
			ctx = unheld(ctx)
		}
	}
	held := holding(ctx)
	c.Lock()
	e, ok := c.m[key]
	if ok && (held || time.Since(e.at) < time.Minute) {
		c.Unlock()
		if held {
			if e.readAt.IsZero() {
				e.readAt = e.at // as it really was: a careful provider counts its age
			}
			e.at = time.Now() // as good as it gets until asked: Allowances keeps it its minute
		}
		return e
	}
	entry := func(read SubscriptionQuota) loginUsageEntry {
		q := read
		if q.Error != "" && ok && q.Provider != "claude" {
			q = e.q // a hiccup keeps what was known
		}
		return loginUsageEntry{at: time.Now(), q: q, read: read}
	}
	r := c.pending[key]
	if r == nil && held {
		// nothing read since magpie started: the reading kept on disk,
		// as of when it was made
		c.Unlock()
		return entry(keepLast(SubscriptionQuota{Provider: loginProvider(l), Plan: l.Plan, Windows: []QuotaWindow{}, Error: errNotAsked.Error()}, l.User))
	}
	if r == nil {
		if stale {
			takeStaleRead(key)
		}
		r = &loginRead{done: make(chan struct{})}
		if c.pending == nil {
			c.pending = map[string]*loginRead{}
		}
		c.pending[key] = r
		ctx, _ = quotaReading(ctx)
		asked := claudeAskGeneration.Load()
		go func() {
			// read for all who wait for it: no one's ctx cuts it short, but
			// it is bounded as the Usage page's refresh is
			rctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), subscriptionTimeout)
			defer cancel()
			r.e = entry(keepReading(rctx, readNow(loginQuota(rctx, l)), l.User))
			c.Lock()
			// one dropped meanwhile (StaleAllowance) read too soon, and a
			// Claude account the user asked to see meanwhile is read again
			// (AskClaudeUsage), as SubscriptionUsage reads it: neither is kept
			if c.pending[key] == r {
				delete(c.pending, key)
				if l.Agent != "claude" || claudeAskGeneration.Load() == asked {
					if c.m == nil {
						c.m = map[string]loginUsageEntry{}
					}
					c.m[key] = r.e
				}
			}
			c.Unlock()
			close(r.done)
		}()
	}
	c.Unlock()
	select {
	case <-r.done:
		return r.e
	case <-ctx.Done():
		// given up on: as a reading cut short would have said
		return entry(keepReading(ctx, SubscriptionQuota{Provider: loginProvider(l), Plan: l.Plan, Windows: []QuotaWindow{}, Error: ctx.Err().Error()}, l.User))
	}
}

// usageLogins are the accounts whose allowance LoginUsage asks for, each
// read once a minute as its Agent: a plugin's accounts, asked for by the
// provider's id or as plugin:<id>, whichever names them, as plugin:<id>.
// False for an agent that tells none, and for the built-in Grok, read by
// home.
func usageLogins(agent string) (logins []Login, ok bool) {
	if pp, ok := pluginOfAgent(agent); ok {
		return pluginUsageLogins(pp), true
	}
	if agent == "grok" {
		return nil, false
	}
	return builtinLogins(agent)
}

// builtinLogins are the accounts of a built-in subscription whose
// allowance can be asked; false for an agent that tells none.
func builtinLogins(agent string) (logins []Login, ok bool) {
	switch agent {
	case "claude", "codex":
		logins = Logins(agent)
	case "copilot":
		logins = copilotLoginList()
	case ChatGPTAPIID:
		logins = siwcLoginList()
	case "gemini", "antigravity":
		logins = googleLoginList(agent)
	default:
		return nil, false
	}
	return logins, true
}

// loginProvider is the id of the provider l signs in: a plugin's
// ("plugin:grok") is its provider's, grok for a moved Grok, whose proxy
// picks are kept under it.
func loginProvider(l Login) string {
	if id, ok := strings.CutPrefix(l.Agent, "plugin:"); ok {
		return PluginID(id)
	}
	return l.Agent
}

func loginQuota(ctx context.Context, l Login) SubscriptionQuota {
	ctx = ViaLogin(ctx, loginProvider(l), l.User) // asked through the account's own proxy
	if strings.HasPrefix(l.Agent, "plugin:") {
		return pluginLoginQuota(ctx, l)
	}
	if l.Agent == "gemini" || l.Agent == "antigravity" {
		return googleLoginQuota(ctx, l)
	}
	if l.Agent == "copilot" {
		for _, c := range copilotLogins(copilotConfigDir()) {
			if strings.EqualFold(c.User, l.User) {
				orig := c.app
				q := copilotSubscriptionUsage(ctx, c.app.Token, c.app.Host)
				// an editor's stale token, the CLI signed in to the same
				// account: read as the requests are sent (#1238)
				if q.Error == http.StatusText(http.StatusUnauthorized) {
					if cli, ok := copilotStandIn(c.app); ok {
						copilotRefuse(c.app.Token, http.StatusUnauthorized)
						c.app = cli
						q = copilotSubscriptionUsage(ctx, cli.Token, cli.Host)
					}
				}
				// GitHub refused the token, with none in its place: the
				// account is signed out (echo_ts on Discord)
				if q.Error == http.StatusText(http.StatusUnauthorized) {
					copilotRefuse(orig.Token, http.StatusUnauthorized)
					copilotRefuse(c.app.Token, http.StatusUnauthorized)
					copilotLapse(orig)
					q.Error = copilotLapsedText
				}
				if q.Error == "" {
					copilotUnlapse(orig)
					refreshCopilotEntitlement(c.app, q.Plan, q.AccessSKU)
				}
				return q
			}
		}
		return SubscriptionQuota{Provider: l.Agent, Plan: l.Plan, Windows: []QuotaWindow{}, Error: "not signed in"}
	}
	q := SubscriptionQuota{Provider: l.Agent, Plan: l.Plan, Windows: []QuotaWindow{}}
	if l.Agent == "claude" && !l.Active {
		// a saved account: what Claude Code told of it, or, when its card
		// is refreshed, its /usage run in the account's own directory
		ws, err := claudeWindows(ctx, l.User, false)
		q.Windows = ws
		if err != nil {
			q.Error = err.Error()
		} else {
			q.ReadAt = claudeReadAt(l.User)
		}
		return q
	}
	var tok, accountID string
	var err error
	var renew codexRenew
	switch {
	case l.Agent == "claude": // Claude Code reads its own (claudeWindows)
	case l.Active && leftAlone(l.Agent):
		// read for the Codex app's hold alone (codexHoldReading): the
		// token as Codex keeps it, never renewed nor written by magpie
		tok, accountID, err = codexTokenAsKept(codexHome())
	case l.Active:
		tok, accountID, err = codexToken(ctx, codexHome())
		renew = func(ctx context.Context, stale string) (string, string, error) {
			return codexTokenRenewing(ctx, codexHome(), stale)
		}
	default:
		tok, accountID, err = savedLoginToken(ctx, l.Agent, l.User)
		agent, user := l.Agent, l.User
		renew = func(ctx context.Context, stale string) (string, string, error) {
			return renewSavedLoginFrom(ctx, agent, user, stale)
		}
	}
	if err == nil {
		if l.Agent == "claude" {
			if q.Windows, err = claudeWindows(ctx, l.User, true); err == nil {
				q.ReadAt = claudeReadAt(l.User)
			}
		} else {
			var plan string
			if plan, q.Windows, q.Resets, q.Balance, q.Held, err = codexWindowsRenewing(ctx, tok, accountID, renew); plan != "" {
				q.Plan = plan
			}
			q.Until = codexUntil(codexLoginAuth(l), time.Now())
		}
	}
	if l.Agent == "codex" {
		err = codexSignInRead(l, tok, err)
	}
	if err != nil {
		q.Error = err.Error()
	}
	return q
}

// codexSignInRead keeps what a ChatGPT account's usage read, made with
// access token tok, said of its sign-in (charliepu on Discord: an account
// showing no allowance, OpenAI having signed it out, till it was signed in
// again). Turned away for the sign-in itself with a refresh tried, or the
// refresh of the one Codex is signed in to refused, the account is marked
// signed out as a revoked one is (signin_revoked.go): its row says Sign in
// again, which runs magpie's sign-in for it and replaces its tokens, and
// the gateway passes over it till then. A saved account's refused refresh
// is marked lapsed already (savedRefreshFailed). A read that went through
// clears a mark it had. Anything else is unknown and marks nothing.
func codexSignInRead(l Login, tok string, err error) error {
	if err == nil {
		ServedSignIn(&Account{Agent: l.Agent, User: l.User})
		return nil
	}
	var refused refreshRefused
	if !l.Active && errors.As(err, &refused) {
		return err
	}
	m := bearerMark(codexGoneFor(err, tok, func() []byte { return codexLoginAuth(l) }))
	if m == "" {
		return err
	}
	markRevoked(l.Agent, l.User, m)
	return errors.New(revokedText(l.User))
}

// CodexUsedUp reports whether the ChatGPT account Codex is signed in to is
// out for the Codex app, which then sends nothing for it (codexHeld): out
// of its allowance with no credits to go on with. A window at 100% with
// credits left isn't (the Codex app keeps sending, and the backend
// answers). False when that isn't known.
func CodexUsedUp(ctx context.Context) bool {
	if leftAlone("codex") {
		return codexReadingHeld(codexHoldReading(ctx))
	}
	// read as LoginUsage has it, fetched at most once a minute: the agent
	// package asks on every catalog sync. Only the account Codex is
	// signed in to counts (codexReadingHeld), so only it is read
	var active []string
	for _, l := range Logins("codex") {
		if l.Active {
			active = append(active, l.User)
		}
	}
	return codexReadingHeld(someLoginUsage(ctx, "codex", active...))
}

// CodexHoldMatters is set by the agent package: whether Codex is wired to
// magpie beside its ChatGPT sign-in, so that magpie becomes its provider
// while the Codex app holds the account (codex.out), or is its provider
// for that already. Nil or false: what the app holds changes nothing.
var CodexHoldMatters func() bool

// codexHoldReading is the reading CodexUsedUp goes by for a Codex switched
// off or removed in magpie (leftAlone), which LoginUsage reads nothing
// of: the account Codex is signed in to alone, only while Codex takes
// magpie's models (CodexHoldMatters), at most once a minute (loginReading),
// its sign-in never renewed (loginQuota). The Codex app greys Send for
// every model, magpie's too, while it holds the account, and turning
// Codex off in magpie once its allowance ran out left the app so for good:
// nothing read, magpie never became its provider, and one that was
// stopped being it (sherlock_23333 on X).
func codexHoldReading(ctx context.Context) map[string]SubscriptionQuota {
	if settings.AccountDiscoveryOff() || CodexHoldMatters == nil || !CodexHoldMatters() {
		return nil
	}
	for _, l := range Logins("codex") {
		if l.Active {
			return map[string]SubscriptionQuota{l.User: loginReading(ctx, l).q}
		}
	}
	return nil
}

// CodexUsedUpKnown is CodexUsedUp over what was read already, asking no
// one and waiting for no one. False when nothing was read yet, which is
// CodexUsedUp's own answer for an account it can't tell about.
//
// For a caller on a path that must not do I/O: agent.SyncCatalog runs
// inside a write's own request (a routing group's Save), and the reading
// there is one the vendor is asked for over the network — a save waited
// 1.1s of the miss of its minute's cache. Nothing is lost by not asking:
// KeepOnAnAccountWithRoom reads it every loginSwitchEvery and
// noteCodexUsedUp tells the catalog when the answer changes, which is what
// the sync is reacting to, and the Usage page and routing read it as the
// user looks at them.
func CodexUsedUpKnown() bool {
	return codexReadingHeld(knownLoginUsage("codex"))
}

// codexReadingHeld is whether the reading u has the ChatGPT account Codex
// is signed in to held by the Codex app. The held of one account's
// reading, not codexHeld, which is what one vendor reply says.
func codexReadingHeld(u map[string]SubscriptionQuota) bool {
	for _, l := range Logins("codex") {
		if q, ok := u[l.User]; l.Active && ok && q.Error == "" && q.Held {
			return true
		}
	}
	return false
}

// knownLoginUsage is LoginUsage over the readings already in hand, with
// no reading asked for: an account not read yet is left out, which its
// callers read as "not known".
func knownLoginUsage(agent string) map[string]SubscriptionQuota {
	logins, ok := usageLogins(agent)
	if !ok {
		return map[string]SubscriptionQuota{}
	}
	out := map[string]SubscriptionQuota{}
	for _, l := range logins {
		if e, ok := loginReadingKnown(l); ok {
			out[l.User] = e.q
		}
	}
	return out
}

// loginReadingKnown is what is known of l's allowance without asking:
// loginReading's cache alone, and none of its reading. False when the
// cache has nothing at all for the account.
func loginReadingKnown(l Login) (loginUsageEntry, bool) {
	key := l.Agent + "/" + strings.ToLower(l.User)
	c := &loginUsageCache
	c.Lock()
	defer c.Unlock()
	e, ok := c.m[key]
	return e, ok
}

// codexLoginAuth is the auth.json of a ChatGPT account magpie knows: the
// sign-in Codex goes by (auth.json or its keychain item), or the one kept for it.
func codexLoginAuth(l Login) []byte {
	if l.Active {
		b, _, _ := readCodexLogin(codexHome(), false)
		return b
	}
	loginsMu.Lock()
	defer loginsMu.Unlock()
	for _, x := range readLogins() {
		if x.Agent == "codex" && strings.EqualFold(x.User, l.User) {
			// as Codex keeps it in its other folder, when it is signed in there
			if home := codexHeldIn(x); home != "" {
				if b, _, err := readCodexLogin(home, false); err == nil {
					return b
				}
			}
			return x.Auth
		}
	}
	return nil
}