Skip to content

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

10.8 KB
Raw Blame
package agent

import (
	"cmp"
	"slices"
	"strings"
	"sync"
	"time"

	"github.com/yetone/magpie/internal/catalog"
	"github.com/yetone/magpie/internal/gateway"
	"github.com/yetone/magpie/internal/provider"
	"github.com/yetone/magpie/internal/settings"
)

// Every agent's model picker has two halves: the models the agent reaches
// on its own (its sign-in, its own keys), and magpie's catalog — every model
// of every provider the user added, reached through the local gateway.
// A catalog model is spelled "provider/model"; an agent that sends that to
// the gateway gets the vendor's reply in whichever API the agent speaks.

// magpieID is the provider id agents know the gateway by.
const magpieID = "magpie"

// RoutingGroups is the picker's group of routing groups.
const RoutingGroups = "Routing groups"

// viaMagpie lists the catalog as agent is shown it, for a picker: the
// routing groups first, in one group of their own, then one group per
// provider.
func viaMagpie(agent, prefix string) []Option {
	var out, groups []Option
	shown, _ := provider.CatalogFor(agent)
	// own: whether a provider is the account the agent is signed in to,
	// asked once a provider (OwnPaused reads the saved logins); a plugin's
	// for the agent's own vendor (Grok moved onto its plugin) is when it
	// is the account the agent itself is signed in to
	own := map[string]bool{}
	for _, e := range shown {
		a := e.Provider.Account
		if a == nil || a.StandIn() {
			continue
		}
		if _, ok := own[e.Provider.ID]; ok {
			continue
		}
		if a.Agent == agent {
			own[e.Provider.ID] = !e.Provider.OwnPaused()
		} else if e.Provider.PluginProvider() == agent && a.User != "" {
			own[e.Provider.ID] = a.User == provider.AgentUser(agent)
		}
	}
	// firstUser: the account a request for a subscription's model goes to
	// first, which the note names. A Codex or Claude Code subscription is
	// the account the agent is signed in to (Account.User), but its
	// requests go to the first in magpie's order: another one when that
	// one is paused, or when the agent is kept signed in to an account
	// that isn't first (#1957, parkavenue9639: every codex/gpt-* read
	// "A · via magpie" while each went to B). Asked once a provider.
	firsts := map[string]string{}
	firstUser := func(p provider.Provider) string {
		a := p.Account
		if a.Agent != p.ID || a.StandIn() {
			return a.User
		}
		u, ok := firsts[p.ID]
		if !ok {
			u = cmp.Or(provider.FirstLogin(a.Agent), a.User)
			firsts[p.ID] = u
		}
		return u
	}
	fast, ultra := provider.FastPicks(agent), provider.UltraPicks(agent)
	var tiered map[string]bool // provider.UltraModels, read at the first fast model
	for _, e := range shown {
		if e.Group != "" {
			groups = append(groups, Option{Value: prefix + e.ID, Label: e.Name, Note: "routing group · via magpie",
				Icon: e.Provider.Icon, Icons: e.Icons, Group: RoutingGroups, Ref: e.ID})
			continue
		}
		note := e.Provider.Name + " · via magpie"
		if a := e.Provider.Account; a != nil {
			note = firstUser(e.Provider) + " · via magpie"
		}
		o := Option{Value: prefix + e.ID, Label: e.Name, Note: note,
			Icon: e.Provider.Icon, Group: e.Provider.Name, Ref: e.ID, Free: e.Free, Rate: e.Rate, RateWas: e.RateWas, Context: e.Context, own: own[e.Provider.ID],
			sub: e.Provider.Account != nil && (e.Provider.Account.Agent != "claude" || agent == "claude")}
		// a model with a fast mode is switched fast in the picker (#954)
		if provider.CanFast(e.Provider, e.Model) {
			o.FastFor, o.Fast = agent, slices.Contains(fast, e.ID)
			o.OwnFast = provider.OwnFast(e.Provider, e.Model)
			if tiered == nil {
				tiered = provider.UltraModels()
			}
			if provider.UltraOn(e.Provider, e.Model, tiered) {
				o.UltraOK, o.Ultra = true, o.Fast && slices.Contains(ultra, e.ID)
			}
		}
		out = append(out, o)
	}
	return append(groups, out...)
}

// listLabels are the names the agent's own list calls the catalog's models
// by, by id: provider.Labels, which follows the Provider in model names
// setting, where an Option's Label is the name alone for magpie's picker.
func listLabels(agent string) map[string]string {
	shown, _ := provider.CatalogFor(agent)
	labels := provider.Labels(shown)
	out := make(map[string]string, len(shown))
	for i, e := range shown {
		out[e.ID] = labels[i]
	}
	return out
}

// isMagpie reports whether a model value is a catalog reference.
func isMagpie(v string) bool {
	if pid, _, ok := strings.Cut(v, "/"); ok && dryProviders[pid] {
		return true
	}
	if !strings.Contains(v, "/") {
		return false
	}
	return magpieRefs.get(v, func() bool {
		_, _, ok := provider.Resolve(v)
		return ok
	})
}

// magpieRefs keeps isMagpie's answers while provider.StampNow stays the
// same, for a minute at most. Outside a request that holds the catalog,
// each Resolve built every provider's entries again: the window's drift
// poll, every 15s, asked it for each agent's values, ~6 MB a poll (the
// procmem heap profile: 235 MB of 1.37 GB in 10 minutes of GUI use).
var magpieRefs stampedRefs

// stampedRefs is a model value → answer, dropped when the stamp moves,
// after a minute (what the stamp can't see: an account another program
// signed in to), or once it holds more values than any config has.
type stampedRefs struct {
	mu    sync.Mutex
	stamp provider.Stamp
	at    time.Time
	of    map[string]bool
}

const (
	stampedRefsFor = time.Minute
	stampedRefsMax = 4096
)

func (s *stampedRefs) get(v string, build func() bool) bool {
	st := provider.StampNow()
	s.mu.Lock()
	if s.stamp != st || time.Since(s.at) >= stampedRefsFor || len(s.of) >= stampedRefsMax {
		s.stamp, s.at, s.of = st, time.Now(), nil
	}
	if ok, found := s.of[v]; found {
		s.mu.Unlock()
		return ok
	}
	s.mu.Unlock()
	// built from what is there after st was taken: never older than st
	ok := build()
	s.mu.Lock()
	if s.stamp == st {
		if s.of == nil {
			s.of = map[string]bool{}
		}
		s.of[v] = ok
	}
	s.mu.Unlock()
	return ok
}

func firstOf(xs []string) string {
	if len(xs) > 0 {
		return xs[0]
	}
	return ""
}

// magpieModels is the catalog as agent is shown it, as catalog.Models, for
// agents that keep their own model files.
func magpieModels(agent string) []catalog.Model {
	// the providers built once for all the models' prices, not for each:
	// dsh's round at every start built them for each of hundreds
	defer provider.Hold()()
	var out []catalog.Model
	shown, _ := provider.CatalogFor(agent)
	labels := provider.Labels(shown)
	// a model magpie describes images to takes them (provider.Described)
	seen := provider.Described != nil && provider.Described()
	st, find := settings.Load(), provider.GroupFinder()
	priceOf := provider.EntryPricer(st, find)
	members := func(id string) []provider.Member {
		_, ms, _ := find(id)
		return ms
	}
	for i, e := range shown {
		m := catalog.Model{ID: e.ID, Name: labels[i], Provider: firstOf(e.Provider.Catalogs()), Efforts: e.Efforts, Images: e.Images || seen, ImageInput: e.ImageInput, Context: e.Context, Output: e.Output, OutputSet: e.OutputSet, AgentsV2: e.AgentsV2, Reasoning: e.Thinks()}
		// where Codex and Claude Code compact it (#876): a threshold the
		// user set on the model or on its provider, else a window they
		// typed whole (#1809), else the one for every model, which codexcat
		// answers from the settings it is given
		m.Compact = provider.CompactFor(st, e, find)
		// what a call costs the user (Pi's cost, #781)
		if pr, ok := priceOf(e); ok {
			m.Price = &pr
		}
		if seen && !e.Images {
			yes := true
			m.ImageInput = &yes
		}
		// APIs is the preferred client protocol, preserving the vendor's
		// own content where possible. A group's members may differ, so a group has
		// one only when every member is served best on Responses (#1594,
		// ObsidianArch02): Pi, omp, droid and dsh then ask it there, and a
		// GPT group's tool-call arguments stream as the member sends them
		// instead of being held for a Chat answer
		if e.Group == "" {
			if n := e.Provider.Native(e.Model); n != "" {
				m.APIs = []string{string(n)}
			} else {
				// Gemini clients also reach Code Assist and Google plugins
				// through the gateway's Gemini API, with translation as needed.
				apis := e.Provider.APIs(e.Model)
				for _, pr := range e.Provider.Speaks() {
					if (pr == provider.Gemini || pr == provider.CodeAssist) && (apis == nil || slices.Contains(apis, pr)) {
						m.APIs = []string{string(provider.Gemini)}
						break
					}
				}
			}
		} else if allResponses(members(e.ID)) {
			m.APIs = []string{string(provider.Responses)}
		}
		// the service tiers Codex is offered on it, as the gateway's own
		// lists offer them: Fast in the Codex CLI magpie writes
		// magpie-models.json for (#1530)
		provider.CodexTiers(&m, e, members)
		if agent == "codex" {
			// the entry its vendor lists the model under in Codex's own
			// shape, handed on as it is (codexcat)
			m.Codex = e.Codex
		}
		// the gateway paths it goes on untranslated, as /v1/models says
		// them: what an agent plugin's connect is told (cleary5779)
		m.Endpoints = provider.NativeEndpoints(e)
		// Codex's /fast on a ChatGPT account's own GPT model, which
		// OpenCode has no command for and takes as variants (#2379); a
		// group is sent fast as the group says, as a fast pick is
		if a := e.Provider.Account; e.Group == "" && a != nil && a.Agent == "codex" {
			m.CodexFast = provider.CanFast(e.Provider, e.Model)
		}
		out = append(out, m)
	}
	return out
}

// allResponses reports whether a group's members are all served best on
// Responses, so the gateway relays a Responses request to whichever it
// picks. A group with none, or one member on another API, is false: a
// Messages-only group stays on Chat too, as the thinking a Claude member
// takes is known by its own model, not by the group's id.
func allResponses(ms []provider.Member) bool {
	for _, m := range ms {
		if m.Provider.Native(m.Model) != provider.Responses {
			return false
		}
	}
	return len(ms) > 0
}

// maxTokens is the output limit an agent is handed for m, kept within the
// context window it is handed with it: models.dev lists some models' output
// above their window (deepseek-chat's 384000 against 128000). An unknown
// window leaves the output as it is.
func maxTokens(m catalog.Model) int { return provider.OutputWithin(m.Context, m.Output) }

// outputOr is the output limit an agent is handed for m: the Max output the
// user set for it (catalog.Model.OutputSet), kept within its window, else
// capped, the agent's own trim of the vendor's figure. A cap of magpie's
// never overrides the user's number: DeepSeek V4.1 Flash set to 384k reached
// VS Code as 250000 and WorkBuddy as 128000 (#2064).
func outputOr(m catalog.Model, capped int) int {
	if n := maxTokens(m); m.OutputSet && n > 0 {
		return n
	}
	return capped
}

// group tags every option with a group name.
func group(name string, opts []Option) []Option {
	for i := range opts {
		opts[i].Group = name
	}
	return opts
}

func gatewayV1() string { return gateway.URL() + "/v1" }