Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package cli
import (
"cmp"
"context"
"errors"
"fmt"
"maps"
"os"
"path/filepath"
"slices"
"strconv"
"strings"
"time"
"github.com/charmbracelet/lipgloss"
"github.com/yetone/magpie/internal/agent"
"github.com/yetone/magpie/internal/catalog"
"github.com/yetone/magpie/internal/gateway"
"github.com/yetone/magpie/internal/provider"
"github.com/yetone/magpie/internal/settings"
"github.com/yetone/magpie/internal/stats"
)
var amber = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#B45309", Dark: "#F2B544"})
const providerUsage = `usage:
magpie providers list providers, keys and who uses them
magpie presets list the vendors magpie knows out of the box
magpie provider <id> show one provider and its models
magpie provider add <preset> <key> add a preset vendor e.g. magpie provider add deepseek sk-…
again, it adds another (deepseek-2); k=v pairs too: id, name, header.X-Foo
magpie provider add <name> k=v… add a custom vendor k: url, anthropic, responses, gemini, decide, key, models, catalog, icon, header.X-Foo, balance, balance.path, balance.method, balance.token, models.url, search, user-agent,
access.key, access.secret (a Volcengine access key, or a Tencent Cloud SecretId and SecretKey, for its plan's windows)
magpie provider set <id> k=v… change a provider's settings, with the same k=v pairs as add;
codex=as-sent sends Codex's Responses requests as Codex sent them
(a relay that checks they are Codex's own), codex=default fits them;
user-agent=agent sends the User-Agent the agent gave (pi, opencode…)
in place of magpie's, for a plan that serves only agents it names;
user-agent=magpie, the default, sends magpie's;
compaction=native asks the provider Codex's own compaction and hands
Codex its sealed item as it came (a Responses API, a ChatGPT account,
Copilot), compaction=magpie, the default, has magpie summarise
routing=smart|order|rotate|usage|pace|weight|free|fast spreads requests
over its keys or accounts (fast: the one that answered fastest lately first);
prompt=as-written sends Antigravity the system prompt exactly as written;
prompt=default, the default, breaks up the lines Google answers with a
false 429 (Codex's, Claude Code's, Hermes' old persona) with a zero-width space
additional-tools=on sends a tool Claude Code's tool search loads to its
Responses API where it was loaded (an additional_tools item, which
keeps the cache); additional-tools=default puts it with the other tools
patience=2m keeps a request to it alone (not through a group) that long
while it is busy or briefly rate limited, asking again after a pause
(at most 4m); patience=off hands the agent the error at once;
patience=default, 1m
magpie provider key <id> <key> change the API key
magpie provider icon <id> <file|name> give a custom provider a picture (PNG, JPEG, SVG…) or a built-in icon
magpie provider fallback <id> <provider/model>… where requests go when it's out of quota or down (none clears)
magpie provider models <id> [ids…] fetch the vendor's model list, or choose which models to expose:
ids… replace the list, +id adds one, -id takes one out, all: the default,
none: serve none of them, its balance and usage still shown,
best: only the newest of each family it lists (Opus 5.6 replaces 5.5 once listed)
magpie provider refresh <id> fetch the vendor's model list again (as the app's Fetch models)
magpie provider refresh-every <id> [6h|1d|off]
have the gateway (magpie serve, the app) fetch the list again by itself
once it is that old (at least 10m; off: only when asked)
magpie provider auto-include <id> [rule…|none]
rules over a model's id, in any case (a glob with *, e.g. 'gpt-*' '*claude*',
or 're:…' a regular expression, where (?-i) makes case matter): the listed models one matches are exposed
now, and each one a later fetch newly lists; picks are only added to
magpie provider account-models <id> [account|key [ids…|all]]
the models one account or key alone serves; all: every model the provider has
magpie provider account-cap <id> [account [percent|off]]
use a subscription account up to a share of each usage window (e.g. 70):
at it, routing takes the account for used up until the window renews
magpie provider account-cap <id> <account> --window <name> [percent|none|default]
a share for one window alone (e.g. "5 hours" 50): none is no cap on it,
default has it follow the account's cap
magpie provider pool <id> [--accounts a,b,…] [--cap percent|off] [--stop on|off] [--careful on|off]
a subscription's accounts as one pool: which are in use and in what order,
each one's cap, --stop: answer 429 at the caps rather than go on to the
fallbacks, --careful: read usage again near a cap, holding what can't be read
magpie provider account-concurrency <id> [account|key [n|off|default]]
how many requests one account or key has out at once, over every model,
routing group and agent: its own, off for none, default for the provider's
magpie provider queue <id> [length [seconds]]
how many may wait for each account or key past its limit, and how long;
past either a request is turned away with a 429 (0: no bound)
magpie provider rpm <id> [n|off] how many requests each account or key sends the vendor in any minute;
one more waits for room, up to 2 minutes, then is turned away with a 429
magpie provider quota-rest <id> [30m|6h|7d|until 08:00|until 00:00+08:00|default]
how long a key sits out once the vendor says it is out of its allowance
without saying when it is back (default: 15 minutes; at most 8 days),
or until the time of day a daily allowance comes back, on this
computer's clock or at the vendor's offset from UTC
magpie provider rest-cap <id> [1m|30m|6h|1d|off|default]
the most a key or account sits out while it keeps failing or being
rate limited, its rest doubling each time from a minute (default:
10 minutes for a failure, 30 for a rate limit; at most 8 days);
off: one that fails without saying why (a relay's 5xx) doesn't
rest at all, while out of quota, its key refused or rate limited
still rests it
magpie provider listed <id> yes|no no: its models serve only through routing groups, not in the list
magpie provider off|on <id> switch it off (kept, but no agent or request uses it), or on again
magpie provider test <id> [--as codex|claude-code] [model…]
send a tiny request through each endpoint, or to each model;
--as asks it as that agent does, for a relay that serves only it
magpie provider rm <id> remove a provider
e.g. magpie provider add "My Relay" url=https://relay.example.com/v1 key=sk-…
magpie provider add "Own Claude" anthropic=https://gw.example.com key=sk-… catalog=anthropic
magpie provider add "My Relay" url=https://relay.example.com/v1 key=sk-… header.X-Org-Id=acme
magpie provider add remote-magpie sk-magpie-… url=http://192.168.1.20:3425 id=office
(another computer's magpie, shared on its network: its models and routing
groups as office/…, each request sent on in the API the agent spoke)
magpie provider add bailian-decision sk-… workspace=<workspace id> (or region=ap-southeast-1, or region=token-plan with an sk-sp- key)
magpie provider add bailian-token-plan sk-sp-… (Bailian's Token Plan: its chat models, and its decision model for routing groups;
qwen-token-plan is the Qwen AI platform's, qwen-decision its pay-as-you-go decision model)
magpie provider add google-vertex project=my-project [email protected]
(Google Vertex AI in your Google Cloud project, with no key: signed with gcloud's
Application Default Credentials (gcloud auth application-default login) unless
credentials=<file> names another, a service account key too; impersonate= needs
roles/iam.serviceAccountTokenCreator on that account; location= global (the
default), us, eu or a region such as us-central1; set changes them, empty clears)
magpie provider add "My Decider" decide=https://decide.example.com/v1 key=sk-… models=my-decision-model
(a System One API, POST …/systemone: it routes groups, its models are never an agent's)
magpie provider add anthropic sk-… id=anthropic-ws2 name="Anthropic WS2" header.anthropic-workspace-id=wrkspc_…
magpie provider set my-relay models.url=https://relay.example.com/api/models catalog=
magpie provider set my-relay search=yes
(the relay answers Claude Code's WebSearch and Codex's web_search itself:
those go to it as sent, not through magpie's own search)
magpie provider add lmstudio address=http://192.168.1.5:1234
magpie provider set lmstudio address=192.168.1.5:1234
(Ollama, LM Studio, oMLX or MLX-Serve on another port or computer: each of its
URLs moves there, keeping its path; address= alone puts it back at the default)
magpie provider set ollama unmasked=yes
(a model on this computer or the local network: Settings' redaction leaves its
requests as written; not for a local relay that passes them on to a vendor)
magpie provider add "My Relay" url=https://relay.example.com/v1 key=sk-… balance=https://relay.example.com/api/usage/token balance.path='$data.total_available / 500000'
magpie provider set my-relay balance.path='(1 - credits.monthlyCredits / 70) %'
magpie provider set my-relay balance.method=POST
(a balance endpoint that answers only a POST: asked with no body)
magpie provider set my-relay balance=https://relay.example.com/api/user/self balance.path='$data.quota / 500000' balance.token=<access token> header.New-Api-User=<user id>
(a new-api relay's whole account: its access token and user id, from its personal settings)
(balance.path: where the amount is in the reply, or a sum of those with + - * / and
brackets; $ or ¥ in front adds the sign, % after it shows a percent of 1;
several go apart by ; each with a label: '5h: a.used / a.cap %; $credits.left';
a list's items are a.*.used, or a[status=active].used for those that match,
in sum() max() min() count(): 'sum(a.*.used) / sum(a.*.cap) %'; one the reply
hasn't shows — and the others still show)
magpie provider set my-relay context=272k context.gpt-6=1m
(context: how long a request agents are told the models take, over what the
vendor or models.dev says; context.<model> for one of them; empty clears)
magpie provider set opencode-go family=ocgo
magpie provider set my-relay id=relay (renames it: groups and agents on my-relay/… move to relay/…)
(family: a tag for which agents are shown its models, see magpie visible)`
// keyColumn is what magpie providers says of p's key or account.
func keyColumn(p provider.Provider) string {
switch {
case p.Off:
return faint.Render("○ switched off")
case p.Account != nil && signedOut(p):
// every account in use refused: listed to be signed in again,
// as the app's row says, never "signed in"
return amber.Render("○ "+p.Account.User+" is signed out") + muted.Render(" · sign in again")
case p.Account != nil:
return green.Render("●") + " " + muted.Render("signed in as "+p.Account.User)
case p.IsVertex() && !p.Ready():
// no project an address can be made of (providers.json edited
// by hand): nothing is asked, as the app's row says
return amber.Render("○ needs a project")
case p.IsVertex():
// no key: a token minted from the user's Google credentials,
// traded for a service account's when it impersonates one
who := "Google credentials"
if p.Vertex != nil && p.Vertex.Impersonate != "" {
who += " as " + p.Vertex.Impersonate
}
return green.Render("●") + " " + muted.Render(who)
case p.Key != "":
return green.Render("●") + " " + muted.Render(provider.Mask(p.Key))
case p.Ready():
return green.Render("●") + " " + muted.Render("no key needed")
default:
return amber.Render("○ no key")
}
}
// signedOut is Provider.SignedOut, for a test to stand in for.
var signedOut = provider.Provider.SignedOut
// providers: `magpie providers`
func providers() error {
all := provider.All()
// a providers.json that can't be read is not "no providers yet": what
// is listed is then the signed-in accounts alone, and it ends in why
bad := provider.FileError()
if len(all) == 0 && len(provider.Excluded()) == 0 {
if bad != nil {
return bad
}
fmt.Println(muted.Render("no providers yet ·"), "magpie provider add deepseek sk-…", muted.Render("· magpie presets lists the vendors"))
return nil
}
uses := usesByProvider()
type row struct{ name, id, host, key, models, uses string }
var rows []row
w := [5]int{}
for _, p := range all {
r := row{name: bold.Render(p.Name), id: muted.Render(p.ID), host: p.Host()}
if p.Preset == "" && p.Account == nil {
r.name += " " + faint.Render("custom")
}
r.key = keyColumn(p)
n := len(p.Exposed())
if t, ok := p.Listed(); ok {
r.models = fmt.Sprintf("%d of %d models", n, len(p.Available())) + muted.Render(" · fetched "+ago(t))
} else {
r.models = fmt.Sprintf("%d models", n)
}
if u := uses[p.ID]; len(u) > 0 {
r.uses = green.Render("← " + strings.Join(u, ", "))
}
if p.Off {
// the user's own switch, kept as they set it: how to undo it
// is said beside it, never done for them
r.uses = strings.TrimSpace(muted.Render("magpie provider on "+p.ID) + " " + r.uses)
}
if e := p.ListError(); e != "" {
r.uses += amber.Render(" ! couldn't list its models: " + e)
}
if len(p.Fallback) > 0 {
r.uses += muted.Render(" ⤷ " + strings.Join(p.Fallback, " → "))
}
for i, s := range []string{r.name, r.id, r.host, r.key, r.models} {
w[i] = max(w[i], lipgloss.Width(s))
}
rows = append(rows, r)
}
for _, r := range rows {
fmt.Printf(" %s %s %s %s %s %s\n", pad(r.name, w[0]), pad(r.id, w[1]), pad(r.host, w[2]), pad(r.key, w[3]), pad(r.models, w[4]), r.uses)
}
for _, x := range provider.Excluded() {
name := x.Agent
if x.Name != "" {
name = x.Name
} else if a, err := agent.Find(x.Agent); err == nil {
name = a.Name
}
fmt.Println()
if x.SignedOut {
fmt.Println(" ", amber.Render("!"), name+"'s saved accounts are not offered: "+x.Why)
continue
}
back := ""
if x.Provider != "" {
back = " · magpie provider add " + x.Provider + " brings it back"
}
fmt.Println(" ", muted.Render(name+" is signed in but not offered: "+x.Why+back))
}
return bad
}
// usesByProvider maps provider ids to the agents currently routed to them.
func usesByProvider() map[string][]string {
out := map[string][]string{}
for _, a := range agent.Detected() {
if len(a.Fields) == 0 {
continue
}
v := a.Fields[0].Get()
v = strings.TrimPrefix(v, "magpie/")
if provider.IsGroupRef(v) {
continue // a routing group, of no one provider
}
if pid, _, ok := strings.Cut(v, "/"); ok {
out[pid] = append(out[pid], a.Name)
}
}
return out
}
// presets: `magpie presets`
func presets() error {
have := map[string]bool{}
for _, p := range provider.All() {
have[p.ID], have[p.Preset] = true, true
}
kind := provider.Kind("")
// partners first, as the app lists them: their heading says they pay
all := []provider.PresetDef{}
var shown []string
for _, pa := range provider.PartnersNow(3 * time.Second) {
all = append(all, pa.PresetDef)
shown = append(shown, pa.ID)
}
provider.CountPartner(provider.PartnerShown, shown...)
provider.NoticePartners(shown...)
for _, pr := range append(all, provider.Presets()...) {
if pr.Kind != kind {
kind = pr.Kind
fmt.Println(faint.Render(" " + map[provider.Kind]string{provider.KindPartner: "partners (sponsors)", provider.KindVendor: "vendors", provider.KindRelay: "relays", provider.KindLocal: "local", provider.KindRemote: "another computer's magpie"}[kind]))
}
name := bold.Render(pr.Name)
if pr.Sponsored && pr.Kind != provider.KindPartner {
name += " " + faint.Render("sponsored")
}
state := muted.Render("magpie provider add " + pr.ID + " <key>")
if pr.NoKey {
state = muted.Render("magpie provider add " + pr.ID)
}
if pr.ID == provider.VertexPreset {
state = muted.Render("magpie provider add " + pr.ID + " project=<project id>")
}
if have[pr.ID] {
state = green.Render("✓ added")
}
fmt.Printf(" %s %s %s\n", pad(name, 28), pad(muted.Render(pr.ID), 14), state)
}
return nil
}
// models: `magpie models [<agent>]` — the catalog every agent sees, or the
// one agent is shown and what is kept from it
func models(args []string) error {
entries := provider.Catalog()
bad := provider.FileError() // as in providers: said, not "no models yet"
var hidden []provider.Entry
agentID := ""
if len(args) > 0 {
q := strings.TrimPrefix(args[0], "--agent=")
if q == "--agent" && len(args) > 1 {
q = args[1]
}
a, err := agent.Find(q)
if err != nil {
return err
}
agentID = a.ID
entries, hidden = provider.CatalogFor(agentID)
}
if _, only := provider.PickedModels(agentID); len(entries) == 0 && agentID != "" && only {
fmt.Println(amber.Render("!"), agentID, "is shown none of them: it is shown only the models picked for it, and none is", muted.Render("· tick some in its list on the Agents page, or magpie visible "+agentID+" --show-new"))
} else if len(entries) == 0 && agentID != "" {
names, _ := provider.VisibleTo(agentID)
fmt.Println(amber.Render("!"), agentID, "is shown none of them: nothing is in", strings.Join(names, ", "), muted.Render("· magpie visible "+agentID+" all shows it every model"))
} else if len(entries) == 0 && bad != nil {
return bad
} else if len(entries) == 0 {
fmt.Println(muted.Render("no models yet · add a provider first:"), "magpie provider add deepseek sk-…")
return nil
}
w := 0
for _, e := range entries {
w = max(w, len(e.ID))
}
last := ""
for _, e := range entries {
head, name := e.Provider.ID, e.Provider.Name
if e.Group != "" {
head, name = provider.GroupPrefix, "Routing groups"
}
if head != last {
last = head
fmt.Println(faint.Render(" " + name))
}
line := " " + pad(e.ID, w)
if e.Name != "" && e.Name != e.Model {
line += " " + muted.Render(e.Name)
}
if len(e.Efforts) > 0 {
line += faint.Render(" " + strings.Join(e.Efforts, "/"))
}
fmt.Println(line)
}
if agentID != "" {
explainHidden(agentID, hidden)
}
// the models a provider's list has that it doesn't expose, which a
// group naming one finds "not served" (MOMO on Discord: 35 of 37)
for _, p := range provider.All() {
if !p.On() || p.Unlisted || p.ServesNone() {
continue
}
if ids, why := notExposed(p); len(ids) > 0 {
fmt.Println(faint.Render(" "+p.Name+": "+plural(len(ids), "more model")+" in its list, not exposed ("+why+"): ") + muted.Render(listSome(ids, 6)))
fmt.Println(faint.Render(" magpie provider models " + p.ID + " +<model> exposes one"))
}
}
fmt.Println(faint.Render(" " + advertisedURL() + "/v1"))
return bad
}
// notExposed are the models p's list has that it doesn't expose, and why:
// the user picked others, or no picks and the list is longer than magpie
// exposes by default.
func notExposed(p provider.Provider) ([]string, string) {
shown := map[string]bool{}
for _, m := range p.Exposed() {
shown[m.ID] = true
}
var out []string
for _, m := range p.Available() {
if !shown[m.ID] {
out = append(out, m.ID)
}
}
why := "not picked"
if len(p.Models) == 0 && p.BestInFamily {
why = "best in family: an older one of its family"
} else if len(p.Models) == 0 {
why = fmt.Sprintf("none picked, so only the first %d", len(shown))
}
return out, why
}
// listSome is ids joined, the first n of them and how many more.
func listSome(ids []string, n int) string {
if len(ids) > n {
return strings.Join(ids[:n], ", ") + fmt.Sprintf(" … %d more", len(ids)-n)
}
return strings.Join(ids, ", ")
}
// providerCmd: `magpie provider <verb> …`
func providerCmd(args []string) error {
if len(args) < 2 {
return fmt.Errorf("%s", providerUsage)
}
verb, rest := args[1], args[2:]
switch verb {
case "add":
return addProvider(rest)
case "set":
// the same k=v pairs as add, on a provider already here
if len(rest) < 2 {
return fmt.Errorf("magpie provider set <id> k=v…\n\n%s", providerUsage)
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
// id= renames it: the rest is saved under the id it has, then the
// groups and agents on its models move to the new one
from := p.ID
before := *p
if err := applyPairs(p, rest[1:]); err != nil {
return err
}
to := strings.ToLower(strings.TrimSpace(p.ID))
p.ID = from
if err := provider.Save(*p); err != nil {
return err
}
if to != from {
moved, err := agent.RenameProvider(from, to)
if err != nil {
return err
}
p.ID = to
if len(moved) > 0 {
fmt.Println(green.Render("✓"), strings.Join(moved, ", "), "moved to", to+"/…")
}
}
fmt.Println(green.Render("✓"), "saved", p.Name, muted.Render("("+p.ID+")"))
if !slices.Equal(before.Models, p.Models) {
// models= replaces the picks, as provider models does
printPicksChange(before, *p, nil)
}
return nil
case "key":
if len(rest) != 2 {
return fmt.Errorf("magpie provider key <id> <key>")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if p.IsVertex() {
return fmt.Errorf("%s is asked with your Google credentials, not an API key · magpie provider set %s credentials=<file> impersonate=<service account> changes them", p.Name, p.ID)
}
p.Key = rest[1]
if err := provider.Save(*p); err != nil {
return err
}
fmt.Println(green.Render("✓"), p.Name, "key", muted.Render(provider.Mask(p.Key)))
return nil
case "icon":
if len(rest) != 2 {
return fmt.Errorf("magpie provider icon <id> <picture file | built-in name | \"\">")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if p.Account != nil || p.Preset != "" {
return fmt.Errorf("%s has its own icon; only a custom provider takes one", p.Name)
}
p.Icon = rest[1]
if err := applyPairs(p, []string{"icon=" + rest[1]}); err != nil {
return err
}
if p.Icon == "" {
p.Icon = "generic"
}
if err := provider.Save(*p); err != nil {
return err
}
fmt.Println(green.Render("✓"), p.Name, "icon", muted.Render(p.Icon))
return nil
case "fallback":
// where requests go when this provider is out of quota, rate
// limited or down; "none" clears the list
if len(rest) < 1 {
return fmt.Errorf("magpie provider fallback <id> [provider/model… | group/<id>… | none]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
p.Fallback = nil
if !(len(rest) == 2 && rest[1] == "none") {
for _, id := range rest[1:] {
// a routing group's id ("group/<id>") resolves too: the
// gateway sends the request through the group
if _, _, ok := provider.Resolve(id); !ok {
return fmt.Errorf("magpie knows no model or group %q (magpie models lists them)", id)
}
p.Fallback = append(p.Fallback, id)
}
}
if err := provider.Save(*p); err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
if len(p.Fallback) == 0 {
fmt.Println(p.Name, muted.Render("has no fallback · magpie provider fallback "+p.ID+" <provider/model>…"))
return nil
}
fmt.Println(green.Render("✓"), p.Name, "falls back to", strings.Join(p.Fallback, muted.Render(" → ")),
muted.Render("· when out of quota, rate limited or down"))
return nil
case "rm", "remove", "delete":
if len(rest) != 1 {
return fmt.Errorf("magpie provider rm <id>")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
moved, err := agent.Reseat(func() error { return provider.Delete(p.ID) })
if err != nil {
return err
}
fmt.Println(green.Render("✓"), "removed", p.Name)
printMoved(moved)
return nil
case "test":
// with models named, a request to each of them; else one per endpoint
// --as codex|claude-code, anywhere after test: asked as that agent asks
as := ""
for i := 0; i < len(rest); i++ {
if v, ok := strings.CutPrefix(rest[i], "--as="); ok {
as, rest = v, slices.Delete(slices.Clone(rest), i, i+1)
i--
} else if rest[i] == "--as" && i+1 < len(rest) {
as, rest = rest[i+1], slices.Delete(slices.Clone(rest), i, i+2)
i--
}
}
if len(rest) < 1 {
return fmt.Errorf("magpie provider test <id> [--as codex|claude-code] [model…]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
res, wait := p.Test, 30*time.Second
if models := rest[1:]; len(models) > 0 {
res, wait = func(ctx context.Context) []provider.Result { return p.TestModels(ctx, models) }, 90*time.Second
}
ctx, cancel := context.WithTimeout(provider.TestAs(context.Background(), as), wait)
defer cancel()
ok := true
for _, r := range res(ctx) {
if r.OK {
fmt.Printf(" %s %-10s %s\n", green.Render("✓"), r.Protocol, muted.Render(fmt.Sprintf("%d ms · %s", r.Millis, r.Model)))
} else {
ok = false
msg := r.Error
if r.Status != 0 {
msg = fmt.Sprintf("%d · %s", r.Status, r.Error)
}
if len(rest) > 1 {
msg = r.Model + " · " + msg
}
fmt.Printf(" %s %-10s %s\n", amber.Render("✗"), r.Protocol, msg)
}
}
if !ok {
os.Exit(1)
}
return nil
case "account-models", "account-model":
return accountModelsCmd(rest)
case "account-cap", "account-caps":
return accountCapCmd(rest)
case "pool":
return poolCmd(rest)
case "account-concurrency", "account-limit":
return accountConcurrencyCmd(rest)
case "queue":
return queueCmd(rest)
case "rpm":
return rpmCmd(rest)
case "refresh-every":
return refreshEveryCmd(rest)
case "auto-include":
return autoIncludeCmd(rest)
case "quota-rest":
return quotaRestCmd(rest)
case "rest-cap":
return restCapCmd(rest)
case "listed":
// no: the provider's models leave the list agents see and serve
// only through the routing groups they are in
if len(rest) != 2 || (rest[1] != "yes" && rest[1] != "no") {
return fmt.Errorf("magpie provider listed <id> yes|no")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
p.Unlisted = rest[1] == "no"
if err := provider.Save(*p); err != nil {
return err
}
if p.Unlisted {
fmt.Println(green.Render("✓"), p.Name, muted.Render("serves only through routing groups"))
} else {
fmt.Println(green.Render("✓"), p.Name, muted.Render("its models are listed"))
}
return nil
case "off", "on":
// off: kept with its keys, but agents are given none of its
// models and no request goes to it
if len(rest) != 1 {
return fmt.Errorf("magpie provider %s <id>", verb)
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
moved, err := agent.Reseat(func() error { return provider.SetOff(p.ID, verb == "off") })
if err != nil {
return err
}
defer printMoved(moved)
if verb == "off" {
fmt.Println(green.Render("✓"), p.Name, muted.Render("is switched off: agents are given none of its models"))
} else {
fmt.Println(green.Render("✓"), p.Name, muted.Render("is switched on"))
}
return nil
case "models", "refresh", "fetch":
if len(rest) < 1 {
return fmt.Errorf("magpie provider %s <id> [model ids to expose…]", verb)
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 && verb != "models" {
return fmt.Errorf("magpie provider %s <id> fetches its list · magpie provider models <id> <ids…> picks from it", verb)
}
if len(rest) > 1 {
before := *p
// none: no model served at all, the provider kept for its
// balance and usage (#1818); best: the newest of each family
// the vendor lists (Best in family); all is the vendor's list
// again
none := len(rest) == 2 && rest[1] == "none"
best := len(rest) == 2 && rest[1] == "best"
picks, err := editPicks(*p, rest[1:])
if none || best {
picks, err = nil, nil
}
if err != nil {
return err
}
p.Models, p.NoModels, p.BestInFamily = picks, none, best
if err := provider.Save(*p); err != nil {
return err
}
printPicksChange(before, *p, rest[1:])
return showProvider(*p)
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
ms, dropped, taken, err := p.RefetchTaking(ctx)
if err != nil {
return err
}
fmt.Println(green.Render("✓"), len(ms), "models from", fetchedFrom(*p))
if len(taken) > 0 {
fmt.Println(green.Render("+"), "newly listed, taken by its auto-include rules:", strings.Join(taken, ", "))
}
if len(dropped) > 0 {
fmt.Println(amber.Render("!"), "gone from its list, so no longer picked:", strings.Join(dropped, ", "))
}
if q, err := provider.Find(p.ID); err == nil {
p = q // without the picks just dropped
}
return showProvider(*p)
}
// `magpie provider <id>`
p, err := provider.Find(verb)
if err != nil {
return err
}
return showProvider(*p)
}
// addProvider: `magpie provider add <preset> [key]` or `magpie provider add <name> k=v…`
func addProvider(rest []string) error {
if len(rest) == 0 {
return fmt.Errorf("magpie provider add <preset> <key> or magpie provider add <name> k=v…\n\n%s", providerUsage)
}
if len(rest) == 1 && slices.ContainsFunc(provider.Excluded(), func(x provider.Exclusion) bool { return x.Provider == strings.ToLower(rest[0]) }) {
// a signed-in account the user removed comes back with its picks
if err := provider.ShowAccount(strings.ToLower(rest[0])); err != nil {
return err
}
return announce(strings.ToLower(rest[0]))
}
var p provider.Provider
if pr, err := provider.FromPreset(strings.ToLower(rest[0])); err == nil {
p = pr
if len(rest) > 1 && !strings.Contains(rest[1], "=") {
if p.IsVertex() {
return fmt.Errorf("%s is asked with your Google credentials, not an API key · magpie provider add %s project=<your Google Cloud project's id>", p.Name, p.ID)
}
p.Key = rest[1]
rest = rest[2:]
} else {
rest = rest[1:]
}
} else {
p = provider.Provider{Name: rest[0]}
rest = rest[1:]
}
if err := applyPairs(&p, rest); err != nil {
return err
}
// adding a preset that is already here adds another of it (deepseek-2),
// for another key or another header, rather than replacing the first
id, err := provider.Add(p)
if err != nil && p.IsVertex() && (p.Vertex == nil || strings.TrimSpace(p.Vertex.Project) == "") {
// the pair that gives the project, which Save's words don't name
return fmt.Errorf("%w · magpie provider add %s project=<your Google Cloud project's id>", err, p.Preset)
}
if err != nil {
return err
}
return announce(id)
}
// saveNew saves a provider the user just added, then asks the vendor for
// its models.
func saveNew(p provider.Provider) error {
if err := provider.Save(p); err != nil {
return err
}
id := p.ID
if _, err := provider.Find(id); err != nil {
id = p.Name
}
return announce(id)
}
// announce says a provider was added and asks the vendor for its models.
func announce(id string) error {
saved, err := provider.Find(id)
if err != nil {
return err
}
fmt.Println(green.Render("✓"), "added", saved.Name, muted.Render("("+saved.ID+")"))
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
if ms, err := saved.Fetch(ctx); err == nil {
fmt.Println(green.Render("✓"), len(ms), "models from", fetchedFrom(*saved))
} else if !saved.DecideOnly() {
// the URLs asked and what they said; the base stays as given
fmt.Println(amber.Render("!"), muted.Render(err.Error()))
}
n := len(saved.Exposed())
if saved.DecideOnly() {
fmt.Println(" it routes groups: magpie group set <id> effort=auto classifier="+saved.ID+"/"+saved.Jev(),
muted.Render("· or a rule's intent=…"))
return nil
}
if n == 0 {
fmt.Println(amber.Render("!"), "no models exposed yet ·", "magpie provider models", saved.ID, "<ids…>")
} else {
fmt.Printf(" %d models in the catalog · %s\n", n, muted.Render("magpie models"))
}
return nil
}
func showProvider(p provider.Provider) error {
kv := func(k, v string) {
// a plugin's provider is reached through the plugin, not a URL
if v != "" && !strings.HasPrefix(v, "plugin://") {
fmt.Printf(" %s %s\n", muted.Render(pad(k, 10)), v)
}
}
name := bold.Render(p.Name) + muted.Render(" "+p.ID)
if p.Preset == "" && p.Account == nil {
name += faint.Render(" custom")
}
fmt.Println(" ", name)
kv("chat", p.Chat)
kv("responses", p.Responses)
kv("anthropic", p.Anthropic)
kv("gemini", p.Gemini)
if p.Searches {
kv("search", "by itself"+muted.Render(" a client's web search goes to it as sent"))
}
if p.PassUserAgent {
why := " the User-Agent the agent gave, not magpie's"
if !p.PassesUserAgent() {
why = " but magpie's: it goes as a client of " + p.Name + "'s own"
}
kv("user-agent", "agent's"+muted.Render(why))
}
if p.Unredacted {
why := " local: Settings' redaction leaves its requests as written"
if !p.SkipsRedaction() {
why = " but masked: not every address of it is on this computer or the local network"
}
kv("unmasked", "yes"+muted.Render(why))
}
if p.NativeCompaction {
kv("compaction", "native"+muted.Render(" Codex's own, sealed by the key or account that answers it"))
}
switch {
case p.Account != nil:
who := p.Account.User
if p.Account.Plan != "" {
who += muted.Render(" " + p.Account.Plan)
}
from := p.Account.Agent + "'s own sign-in"
if p.IsPlugin() {
from = p.Name + "'s sign-in"
if provider.PluginServes(p.ID) {
from = p.ID + "'s own sign-in" // as the built-in said
}
}
kv("account", who+muted.Render(" from "+from))
case p.IsVertex():
// no key: where its requests go, and the Google credentials that
// sign them
v := provider.Vertex{}
if p.Vertex != nil {
v = *p.Vertex
}
project := v.Project
if !p.Ready() {
project = amber.Render(cmp.Or(project, "not set")) + muted.Render(" magpie provider set "+p.ID+" project=…")
}
kv("project", project)
kv("location", v.Location)
creds := v.Credentials
if creds == "" {
creds = "gcloud's Application Default Credentials" + muted.Render(" gcloud auth application-default login")
}
kv("signs with", creds)
kv("as", v.Impersonate)
case p.Key != "":
kv("key", muted.Render(provider.Mask(p.Key)))
case p.Ready():
kv("key", muted.Render("none needed"))
default:
kv("key", amber.Render("not set")+muted.Render(" magpie provider key "+p.ID+" …"))
}
kv("catalog", p.Catalog)
kv("website", p.Website)
kv("keys", p.KeysURL)
ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
if amount, ok, err := provider.Balance(ctx, p); ok {
from := ""
// where it was asked: a panel's key query when its account query
// has no token left to ask with
if u, field := provider.BalanceQuery(p); u != "" {
if p.BalanceMethod != "" {
u = strings.ToUpper(p.BalanceMethod) + " " + u
}
from = muted.Render(" from " + u + " " + field)
}
if err != nil {
kv("balance", amber.Render("unavailable")+muted.Render(" "+err.Error())+from)
} else {
kv("balance", bold.Render(amount)+from)
}
}
cancel()
for _, k := range slices.Sorted(maps.Keys(p.Headers)) {
kv("header", k+": "+muted.Render(p.Headers[k]))
}
if d := p.RefreshInterval(); d > 0 {
kv("refresh", "every "+p.RefreshSchedule()+muted.Render(" the gateway fetches its list by itself"))
}
if len(p.AutoInclude) > 0 {
kv("include", strings.Join(p.AutoInclude, " ")+muted.Render(" newly listed models these match are exposed"))
}
ms := p.Exposed()
src := "models.dev"
if t, ok := p.Listed(); ok {
src = fetchedFrom(p) + " · fetched " + ago(t)
}
kv("models", fmt.Sprintf("%d exposed of %d %s", len(ms), len(p.Available()), muted.Render("from "+src)))
if ids, why := notExposed(p); len(ids) > 0 {
kv("not shown", fmt.Sprintf("%s %s", listSome(ids, 8), muted.Render("· "+why+" · magpie provider models "+p.ID+" +<model> exposes one")))
}
names := p.ModelNames()
for i, m := range ms {
if i == 12 {
fmt.Println(faint.Render(fmt.Sprintf(" … %d more", len(ms)-12)))
break
}
line := " " + p.ID + "/" + m.ID
if n, ok := names[m.ID]; ok {
m.Name = n
}
if m.Name != "" && m.Name != m.ID {
line += muted.Render(" " + m.Name)
}
fmt.Println(line)
}
if u := usesByProvider()[p.ID]; len(u) > 0 {
kv("used by", green.Render(strings.Join(u, ", ")))
}
return nil
}
// atAddress moves p's URLs to addr (provider.AtAddress). A provider
// saved with none, the gateway taking its preset's, is moved from the
// preset's; an empty addr puts a local server's back at its preset's.
func atAddress(p *provider.Provider, addr string) error {
pr := provider.Preset(p.Preset)
if pr != nil && pr.Kind != provider.KindLocal {
pr = nil
}
if pr != nil && (strings.TrimSpace(addr) == "" || p.Chat+p.Responses+p.Anthropic+p.Decide == "") {
p.Chat, p.Responses, p.Anthropic, p.Decide = pr.Chat, pr.Responses, pr.Anthropic, pr.Decide
}
if strings.TrimSpace(addr) == "" {
if pr == nil {
return fmt.Errorf("address= needs an address, such as http://192.168.1.5:1234")
}
return nil
}
if p.Chat+p.Responses+p.Anthropic+p.Decide == "" {
return fmt.Errorf("%s has no URL to move: url= gives its base URL", cmp.Or(p.Name, p.ID))
}
return p.AtAddress(addr)
}
func applyPairs(p *provider.Provider, pairs []string) error {
workspace := ""
for _, kv := range pairs {
k, v, ok := strings.Cut(kv, "=")
if !ok {
return fmt.Errorf("expected key=value, got %q\n\n%s", kv, providerUsage)
}
if p.IsVertex() && slices.Contains([]string{"url", "chat", "openai", "responses", "anthropic", "decide", "address"}, strings.ToLower(k)) {
// asked only at the address its project and location make, so
// that its Google token goes nowhere else: one given here would
// be dropped without a word
return fmt.Errorf("%s is asked at its Google Cloud project's own address: project= and location= say where", p.Name)
}
switch strings.ToLower(k) {
case "id":
p.ID = v
case "name":
p.Name = v
case "url", "chat", "openai":
p.Chat = v
case "responses":
p.Responses = v
case "address":
// a local server (Ollama, LM Studio, oMLX …) on another port
// or computer: every URL it has moves there, each API keeping
// its path, as the window's Server address does
if err := atAddress(p, v); err != nil {
return err
}
case "anthropic":
p.Anthropic = v
case "gemini":
// a Gemini API's base (…/v1beta), Google's or one that
// answers as it does (#1346)
p.Gemini = v
case "decide":
// a System One root (…/systemone is asked under it): the
// provider routes groups, its models any name (#647)
p.Decide = v
case "workspace":
workspace = strings.TrimSpace(v)
case "project", "location", "credentials", "impersonate":
// Google Vertex AI's project and location, and the Google
// credentials that sign its requests in place of a key; empty
// clears one, and location= is global again
if !p.IsVertex() {
return fmt.Errorf("%s= is Google Vertex AI's, and %s isn't Vertex AI", strings.ToLower(k), p.Name)
}
x := provider.Vertex{}
if p.Vertex != nil {
x = *p.Vertex
}
switch v = strings.TrimSpace(v); strings.ToLower(k) {
case "project":
x.Project = v
case "location":
x.Location = v
case "credentials":
// a file named from where the command runs: the gateway,
// which runs nowhere in particular, needs its full path
if v != "" && !filepath.IsAbs(v) && !strings.HasPrefix(v, "~") {
if abs, err := filepath.Abs(v); err == nil {
v = abs
}
}
x.Credentials = v
default:
x.Impersonate = v
}
p.Vertex = &x
case "region", "plan":
pr := provider.Preset(p.Preset)
if p.IsVertex() {
// what Google Cloud calls a region is Vertex AI's location
return fmt.Errorf("%s has no regions or plans to pick: location= says where it is asked (global, us, eu or a region such as us-central1)", p.Name)
}
if pr == nil || len(pr.Regions) == 0 {
return fmt.Errorf("%s has no regions or plans to pick", p.Name)
}
var ids []string
for _, r := range pr.Regions {
ids = append(ids, r.ID)
}
i := slices.IndexFunc(pr.Regions, func(r provider.Region) bool { return strings.EqualFold(r.ID, v) })
if i < 0 {
return fmt.Errorf("%s=%s: %s's are %s", k, v, pr.Name, strings.Join(ids, ", "))
}
r := pr.Regions[i]
p.Chat, p.Responses, p.Anthropic, p.Decide = r.Chat, r.Responses, r.Anthropic, r.Decide
if r.KeysURL != "" {
p.KeysURL = r.KeysURL
}
case "key":
p.Key = v
case "catalog":
p.Catalog = v
case "models":
p.Models = splitIDs(v, nil)
case "website":
p.Website = v
case "keys":
p.KeysURL = v
case "balance":
p.BalanceURL = v
case "balance.path":
p.BalancePath = v
case "balance.method":
// GET (the default) or POST, for an endpoint that answers
// only a POST (#2368)
switch strings.ToUpper(strings.TrimSpace(v)) {
case "GET", "":
p.BalanceMethod = ""
case "POST":
p.BalanceMethod = "POST"
default:
return fmt.Errorf("balance.method=GET|POST, not %q", v)
}
case "balance.token":
p.BalanceToken = v
case "access.key":
// a Volcengine account's access key, which Ark tells its
// Coding or Agent Plan's windows to (#1427), or a Tencent Cloud
// SecretId, which TokenHub tells Token Plan 企业版's usage to (#1574)
p.AccessKeyID = v
case "access.secret":
p.SecretAccessKey = v
case "models.url":
p.ModelsURL = v
case "codex":
// as-sent: Codex's requests go to it as Codex sent them, for
// a relay that checks they are Codex's own (#1758)
switch strings.ToLower(v) {
case "as-sent", "yes", "on":
p.CodexAsSent = true
case "default", "no", "off":
p.CodexAsSent = false
default:
return fmt.Errorf("codex=as-sent|default, not %q", v)
}
case "prompt":
// as-written: Antigravity's subscription is sent the system
// prompt exactly as the agent wrote it, the lines Google turns
// away with a 429 included; default breaks those lines up
// with a zero-width space (Provider.PromptAsWritten)
switch strings.ToLower(v) {
case "as-written", "as-sent", "on", "yes":
p.PromptAsWritten = true
case "default", "no", "off":
p.PromptAsWritten = false
default:
return fmt.Errorf("prompt=as-written|default, not %q", v)
}
case "additional-tools":
// on: a tool an Anthropic client's tool search loads goes to
// the provider's Responses API in an additional_tools item
// where it was loaded, which keeps the cached prefix (#2660)
switch strings.ToLower(v) {
case "on", "yes":
p.AdditionalTools = true
case "default", "no", "off":
p.AdditionalTools = false
default:
return fmt.Errorf("additional-tools=on|default, not %q", v)
}
case "patience":
// how long a request to the provider alone is kept while it
// is busy, as a group's Patience (zoecats on Discord)
n, err := patienceArg(v)
if err != nil {
return err
}
p.Patience = n
case "user-agent", "ua":
// agent: a request goes with the User-Agent the agent that
// sent it gave, for a coding plan that serves only agents it
// names (#1851); magpie: magpie's own, as by default. A
// header.User-Agent the user set stands over both
var on bool
switch strings.ToLower(v) {
case "agent", "pass", "yes", "on":
on = true
case "magpie", "default", "no", "off":
default:
return fmt.Errorf("user-agent=agent|magpie, not %q", v)
}
if on && p.Account != nil {
return fmt.Errorf("%s signs in as its own client, which sends the User-Agent it does; user-agent= is for a provider with an API key", p.Name)
}
p.PassUserAgent = on
case "search":
// yes: the vendor searches the web by itself, a web search a
// client offers going to it as it was sent (a relay in front of
// Anthropic's or OpenAI's API)
if v != "yes" && v != "no" {
return fmt.Errorf("search=yes|no, not %q", v)
}
p.Searches = v == "yes"
case "compaction":
// native: Codex's compaction_trigger goes to the provider as
// Codex sent it, its sealed compaction back to Codex as it
// came (#1099); magpie: magpie's summary, the default
switch strings.ToLower(v) {
case "native", "yes", "on":
p.NativeCompaction = true
case "magpie", "default", "no", "off":
p.NativeCompaction = false
default:
return fmt.Errorf("compaction=native|magpie, not %q", v)
}
case "unmasked":
// yes: a model on this computer or the local network gets the
// requests as written, unmasked by Settings' redaction (lc on
// Discord); only while every address of it is local
// (provider.SkipsRedaction)
if v != "yes" && v != "no" {
return fmt.Errorf("unmasked=yes|no, not %q", v)
}
p.Unredacted = v == "yes"
case "context":
if err := setContext(p, "*", v); err != nil {
return err
}
case "family", "tag":
p.Family = strings.TrimSpace(v)
case "routing", "strategy":
// how requests spread over its keys or accounts, as the
// provider editor's Routing says: a group's names, but a
// provider has no member to pick by hand
r, err := parseRouting(v)
if err != nil {
return err
}
if r == provider.Manual {
return fmt.Errorf("routing=manual is a group's: a provider's keys or accounts are routed smart, order, rotate, usage, pace, weight, free or fast")
}
p.Routing = r
case "icon":
// a picture on disk is kept by magpie; anything else is one of
// the built-in icons' names
if st, err := os.Stat(v); err == nil && !st.IsDir() {
icon, err := provider.StoreIconFile(v)
if err != nil {
return err
}
v = icon
}
p.Icon = v
default:
// header.X-Foo=bar sets a custom request header (name kept as
// typed, replacing one of the same name in any case); an empty
// value leaves it out
if len(k) > len("header.") && strings.EqualFold(k[:len("header.")], "header.") {
name := k[len("header."):]
for h := range p.Headers {
if strings.EqualFold(h, name) {
delete(p.Headers, h)
}
}
if strings.TrimSpace(v) == "" {
continue
}
if p.Headers == nil {
p.Headers = map[string]string{}
}
p.Headers[name] = v
continue
}
if len(k) > len("context.") && strings.EqualFold(k[:len("context.")], "context.") {
if err := setContext(p, k[len("context."):], v); err != nil {
return err
}
continue
}
return fmt.Errorf("unknown field %q\n\n%s", k, providerUsage)
}
}
if p.NativeCompaction && !p.CarriesCompaction() {
return fmt.Errorf("compaction=native: %s can't carry Codex's own compaction; only a provider with a Responses API (responses=), a ChatGPT account or GitHub Copilot can", p.Name)
}
if workspace != "" {
// Bailian's decision model is asked at the workspace's own host
if !strings.Contains(p.Decide, provider.WorkspaceID) {
return fmt.Errorf("workspace= fills in a Bailian workspace's host, and %s's decision API names none", p.Name)
}
p.Decide = strings.ReplaceAll(p.Decide, provider.WorkspaceID, workspace)
}
return nil
}
// setContext sets the context agents are told model takes ("*" for all
// the provider's); empty or 0 leaves it to the vendor and models.dev again.
func setContext(p *provider.Provider, model, v string) error {
n := 0
if strings.TrimSpace(v) != "" {
var err error
if n, err = parseTokens(v); err != nil {
return fmt.Errorf("context: %w", err)
}
}
if n == 0 {
delete(p.Contexts, model)
return nil
}
if p.Contexts == nil {
p.Contexts = map[string]int{}
}
p.Contexts[model] = n
return nil
}
func ago(t time.Time) string {
d := time.Since(t)
switch {
case d < time.Minute:
return "just now"
case d < time.Hour:
return fmt.Sprintf("%dm ago", int(d.Minutes()))
case d < 48*time.Hour:
return fmt.Sprintf("%dh ago", int(d.Hours()))
default:
return t.Format("Jan 2")
}
}
// refreshLive re-fetches the model list of every ready provider; `magpie sync`
// calls it after the catalog download.
func refreshLive(ctx context.Context) {
var names []string
for _, p := range provider.All() {
if !p.Ready() {
continue
}
c, cancel := context.WithTimeout(ctx, 8*time.Second)
ms, err := p.Fetch(c)
cancel()
if err == nil {
names = append(names, fmt.Sprintf("%s (%d)", p.ID, len(ms)))
}
}
if len(names) > 0 {
fmt.Println(green.Render("✓"), "model lists:", strings.Join(names, ", "))
}
}
// keyNote says who the gateway takes any key from: this machine (in a
// container, the container) alone. Shared from Settings, or put on the
// network by MAGPIE_ADDR (a server, a Docker image), it takes others with
// an enabled gateway key.
func keyNote() string {
if settings.Load().LAN || gateway.OnNetwork() {
if gateway.InContainer() {
return "(anything works inside the container; from its host and other machines, an enabled gateway key — magpie gateway-key add <name>)"
}
return "(anything works from this machine; from others, an enabled gateway key — magpie gateway-key add <name>)"
}
return "(anything works; the gateway only listens on localhost)"
}
// containerNote follows the addresses magpie finds for itself in a
// container, which are the container's own.
const containerNote = "these are the container's own addresses: other machines use the host's, and MAGPIE_PUBLIC_URL=http://<host>:<port> puts it here"
// shareLines are where other machines reach the gateway while it is shared
// from Settings, for the banner.
func shareLines() []string {
if s := settings.Load(); !s.LAN || s.LANKey == "" {
return nil
}
var out []string
for _, u := range gateway.LANURLs() {
out = append(out, muted.Render(" network ")+" "+u)
}
if gateway.ContainerAddrs() {
out = append(out, muted.Render(" "+containerNote))
}
return out
}
// advertisedURL is what the CLIs print for other machines: the public
// address when MAGPIE_PUBLIC_URL is valid, otherwise the one reached from
// this machine.
func advertisedURL() string {
if u := gateway.PublicURL(); u != "" {
return u
}
return gateway.URL()
}
// serve: `magpie serve` — the gateway alone, in the foreground.
func serve() error {
s := gateway.New()
go stats.Run(version, "serve")
go catalog.KeepFresh() // new models' prices, in a gateway left running
// a signed-in account's list exists only at its vendor: asked for here
// as the app and the terminal ask (#1789), or a headless gateway offered
// the agents Cursor's fallback Auto alone; asked again while one is left
go func() {
for provider.FetchNew(20 * time.Second) {
time.Sleep(time.Minute)
}
}()
// Codex's background app-server, restarted when it has the list from
// before a change and no codex session is on it
go agent.KeepCodexDaemonCurrent(context.Background())
go agent.KeepCodexRolloutsPortable(context.Background())
public := advertisedURL()
fmt.Println(green.Render("●"), "magpie gateway on", bold.Render(gateway.URL()))
fmt.Println(muted.Render(" OpenAI "), public+"/v1/chat/completions", muted.Render("·"), public+"/v1/responses")
fmt.Println(muted.Render(" Anthropic"), public+"/v1/messages")
fmt.Println(muted.Render(" key "), gateway.Token, muted.Render(keyNote()))
if l := tlsLine(); l != "" {
fmt.Println(l)
}
for _, l := range shareLines() {
fmt.Println(l)
}
n := len(provider.Catalog())
if err := provider.FileError(); err != nil {
fmt.Println(amber.Render("!"), err) // served without it, as no providers
}
if n == 0 {
fmt.Println(amber.Render("!"), "no models yet ·", "magpie provider add deepseek sk-…")
} else {
fmt.Printf(" %d models · %s\n", n, muted.Render("magpie models"))
}
for _, x := range provider.Excluded() {
if x.SignedOut {
fmt.Println(amber.Render("!"), x.Agent+":", x.Why)
}
}
return s.ListenAndServe(context.Background())
}
// importCmd adds the provider a magpie://import link describes, after
// showing it: magpie import [-y] <link>.
func importCmd(args []string) error {
yes := false
var link string
for _, a := range args {
switch a {
case "-y", "--yes":
yes = true
default:
link = a
}
}
if link == "" {
return errors.New("magpie import [-y] 'magpie://import?…'")
}
p, err := provider.ParseImport(link)
if err != nil {
return err
}
if err := showProvider(p); err != nil {
return err
}
if old, err := provider.Find(p.ID); err == nil {
fmt.Println(amber.Render("!"), "replaces your", old.Name)
}
if !yes {
if st, err := os.Stdin.Stat(); err != nil || st.Mode()&os.ModeCharDevice == 0 {
return errors.New("not a terminal: add -y to import without asking")
}
fmt.Print("Add it? [y/N] ")
var answer string
_, _ = fmt.Scanln(&answer)
if a := strings.ToLower(strings.TrimSpace(answer)); a != "y" && a != "yes" {
return errors.New("nothing added")
}
}
if p.Key == "" && !p.Ready() {
fmt.Println(amber.Render("!"), "the link has no key · magpie provider key", p.ID, "<key>")
}
return saveNew(p)
}
// fetchedFrom is where a provider's models were fetched: its API's host, or
// for a subscription run through its own CLI (Kiro, Devin, Cursor …), which
// has none, its name.
func fetchedFrom(p provider.Provider) string {
if h := p.Host(); h != "" {
return h
}
return p.Name
}
// accountModelsCmd: `magpie provider account-models <id> [account|key
// [ids…|all]]` — the models one account or key of a provider alone serves
// (#474), each account's with none named, all for every one the provider has.
func accountModelsCmd(rest []string) error {
if len(rest) < 1 {
return fmt.Errorf("magpie provider account-models <id> [account|key [model ids…|all]]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 2 {
ms := rest[2:]
if len(ms) == 1 && (ms[0] == "all" || ms[0] == "-") {
ms = nil
}
if err := provider.SetAccountModels(p.ID, rest[1], ms); err != nil {
return err
}
}
refs := p.AccountRefs()
if len(rest) > 1 {
ref, _, err := provider.AccountModelsOf(p.ID, rest[1])
if err != nil {
return err
}
refs = []string{ref}
}
if len(refs) == 0 {
fmt.Println(muted.Render(p.Name + " has no account or key"))
return nil
}
label := map[string]string{}
for _, k := range p.KeyList() {
if k.Name != "" {
label[k.ID] = k.Name + " " + muted.Render(k.Masked+" · "+k.ID)
} else {
label[k.ID] = k.Masked + " " + muted.Render(k.ID)
}
}
for _, r := range refs {
name := r
if l, ok := label[r]; ok {
name = l
}
_, ms, _ := provider.AccountModelsOf(p.ID, r)
if len(ms) == 0 {
fmt.Println(name, muted.Render("· every model "+p.Name+" serves"))
} else {
fmt.Println(name, "· only", strings.Join(ms, ", "))
}
}
return nil
}
// accountCapCmd shows, or sets with a share or off, the usage cap of a
// subscription's accounts: the share of each window one is used to at most
// (provider.AccountCaps); with --window <name>, the share of that window
// alone (provider.AccountWindowCaps).
func accountCapCmd(rest []string) error {
usage := fmt.Errorf("magpie provider account-cap <id> [account [percent|off]]\n magpie provider account-cap <id> <account> --window <name> [percent|none|default]")
window, windowSet := "", false
for i := 0; i < len(rest); i++ {
a := rest[i]
if v, ok := strings.CutPrefix(a, "--window="); ok {
window, windowSet = v, true
rest = slices.Delete(slices.Clone(rest), i, i+1)
i--
continue
}
if a == "--window" {
if i+1 >= len(rest) {
return usage
}
window, windowSet = rest[i+1], true
rest = slices.Delete(slices.Clone(rest), i, i+2)
i--
}
}
if len(rest) < 1 || windowSet && (len(rest) < 2 || strings.TrimSpace(window) == "") {
return usage
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if p.Account == nil {
return fmt.Errorf("%s has keys, not subscription accounts with usage windows to cap", p.Name)
}
if len(rest) > 2 {
if windowSet {
cap, err := parseWindowCap(rest[2])
if err != nil {
return err
}
err = provider.SetWindowCap(p.ID, rest[1], window, cap)
if err != nil {
return err
}
} else {
cap, err := provider.ParseCap(rest[2])
if err != nil {
return err
}
if err := provider.SetAccountCap(p.ID, rest[1], cap); err != nil {
return err
}
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
refs := p.AccountRefs()
if len(rest) > 1 {
refs = slices.DeleteFunc(refs, func(r string) bool { return !strings.EqualFold(r, strings.TrimSpace(rest[1])) })
if len(refs) == 0 {
return fmt.Errorf("%s has no account %q", p.Name, rest[1])
}
}
if len(refs) == 0 {
fmt.Println(muted.Render(p.Name + " has no account"))
return nil
}
for _, r := range refs {
caps := p.CapsOf(r)
if caps.All > 0 {
fmt.Printf("%s · capped at %d%% of each usage window\n", r, caps.All)
} else if len(caps.Windows) > 0 {
fmt.Println(r, muted.Render("· no cap on its other windows: used to 100%"))
} else {
fmt.Println(r, muted.Render("· no cap: used to 100%"))
}
for _, w := range slices.Sorted(maps.Keys(caps.Windows)) {
if c := caps.Windows[w]; c >= 100 {
fmt.Printf(" %s · no cap on this window\n", w)
} else {
fmt.Printf(" %s · capped at %d%%\n", w, c)
}
}
}
return nil
}
// parseWindowCap reads a window's own share as the CLI takes it: "50",
// "50%", none (off, 100) for no cap on that window, default (-) to follow
// the account's cap.
func parseWindowCap(s string) (int, error) {
switch strings.ToLower(strings.TrimSpace(s)) {
case "default", "account", "-", "0":
return 0, nil
case "none", "off", "no", "100", "100%":
return 100, nil
}
n, err := provider.ParseCap(s)
if err != nil {
return 0, fmt.Errorf("a window's cap is a share from %d to %d (percent), none for no cap on it, or default to follow the account's cap, not %q", provider.MinCap, provider.MaxCap, s)
}
return n, nil
}
// accountConcurrencyCmd shows, or sets, the limit on requests at once of a
// provider's accounts or keys (#892): each one's own, else the provider's
// Concurrency. What runs and waits now is the gateway's, at GET
// /v1/magpie/concurrency and on the app's account rows.
func accountConcurrencyCmd(rest []string) error {
if len(rest) < 1 {
return fmt.Errorf("magpie provider account-concurrency <id> [account|key [n|off|default]]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 2 {
limit, err := provider.ParseLimit(rest[2])
if err != nil {
return err
}
if err := provider.SetAccountConcurrency(p.ID, rest[1], limit); err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
refs := p.AccountRefs()
if len(rest) > 1 {
ref, ok := p.AccountRefOf(rest[1])
if !ok {
return fmt.Errorf("%s has no account or key %q", p.Name, rest[1])
}
refs = []string{ref}
}
if len(refs) == 0 {
fmt.Println(muted.Render(p.Name + " has no account or key"))
return nil
}
label := map[string]string{}
for _, k := range p.KeyList() {
if k.Name != "" {
label[k.ID] = k.Name + " " + muted.Render(k.Masked+" · "+k.ID)
} else {
label[k.ID] = k.Masked + " " + muted.Render(k.ID)
}
}
base := p.Concurrency()
for _, r := range refs {
name := r
if l, ok := label[r]; ok {
name = l
}
n, own := p.AccountConcurrencyOf(r)
switch {
case own && n > 0:
fmt.Printf("%s · at most %d at once (its own)\n", name, n)
case own:
fmt.Println(name, "· no limit at once (its own)")
case base > 0:
fmt.Println(name, muted.Render(fmt.Sprintf("· at most %d at once (%s's)", base, p.Name)))
default:
fmt.Println(name, muted.Render("· no limit at once"))
}
}
return nil
}
// queueCmd shows, or sets, how many requests may wait for each of a
// provider's accounts or keys past its limit, and for how many seconds
// (#892).
func queueCmd(rest []string) error {
if len(rest) < 1 || len(rest) > 3 {
return fmt.Errorf("magpie provider queue <id> [length [seconds]]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
num := func(s, what string) (int, error) {
if s == "off" || s == "none" || s == "-" {
return 0, nil
}
n, err := strconv.Atoi(s)
if err != nil {
return 0, fmt.Errorf("the %s is a whole number, or off, not %q", what, s)
}
return n, nil
}
ql, err := num(rest[1], "queue length")
if err != nil {
return err
}
qw := p.QueueWait
if len(rest) > 2 {
if qw, err = num(rest[2], "wait in seconds"); err != nil {
return err
}
}
if err := provider.SetQueue(p.ID, ql, qw); err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
length, wait := "no bound", "as long as it takes"
if p.QueueLimit > 0 {
length = fmt.Sprintf("%d", p.QueueLimit)
}
if p.QueueWait > 0 {
wait = fmt.Sprintf("%ds", p.QueueWait)
}
fmt.Printf("%s · queue for each account or key: %s waiting, each for %s\n", p.Name, length, wait)
return nil
}
// rpmCmd shows, or sets, how many requests each of a provider's accounts
// or keys sends the vendor in any minute (coeo91 on Discord: OpenRouter's
// free models take 20).
func rpmCmd(rest []string) error {
if len(rest) < 1 || len(rest) > 2 {
return fmt.Errorf("magpie provider rpm <id> [n|off]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
n := 0
switch s := strings.ToLower(strings.TrimSpace(rest[1])); s {
case "off", "none", "no", "-":
default:
if n, err = strconv.Atoi(s); err != nil {
return fmt.Errorf("requests a minute is a whole number, or off, not %q", rest[1])
}
}
if err := provider.SetRPM(p.ID, n); err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
if n := p.RPMLimit(); n > 0 {
fmt.Printf("%s · each account or key: at most %d requests a minute\n", p.Name, n)
} else {
fmt.Printf("%s · each account or key: no limit on requests a minute\n", p.Name)
}
return nil
}
// quotaRestCmd shows, or sets, how long a provider's keys sit out once the
// vendor says one is out of its allowance without saying when it is back
// (#1772: Ollama Cloud's weekly limit, asked again every 15 minutes).
func quotaRestCmd(rest []string) error {
usage := fmt.Errorf("magpie provider quota-rest <id> [30m|6h|7d|until 08:00|until 00:00+08:00|default]")
if len(rest) == 3 && (rest[1] == "until" || rest[1] == "at") {
rest = []string{rest[0], rest[2]}
}
if len(rest) < 1 || len(rest) > 2 {
return usage
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
// a time of day (#2008): until the daily allowance comes back
if strings.Contains(rest[1], ":") {
err = provider.SetQuotaResetAt(p.ID, rest[1])
} else {
var minutes int
if minutes, err = restMinutes(rest[1]); err == nil {
if err = provider.SetQuotaRest(p.ID, minutes); err == nil && minutes == 0 {
err = provider.SetQuotaResetAt(p.ID, "")
}
}
}
if err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
if t, ok := provider.NextResetAt(p.QuotaResetAt, time.Now()); ok {
fmt.Printf("%s · a key out of its allowance, with no word of when it is back, sits out until %s (next %s)\n", p.Name, p.QuotaResetAt, t.Local().Format("Jan 2 15:04"))
} else if d := p.QuotaRestFor(); d > 0 {
fmt.Printf("%s · a key out of its allowance, with no word of when it is back, sits out %s\n", p.Name, restWords(d))
} else {
fmt.Printf("%s · a key out of its allowance, with no word of when it is back, sits out 15 minutes (magpie's own)\n", p.Name)
}
return nil
}
// restCapCmd sets or shows the most a provider's keys and accounts sit out
// while they keep failing or being rate limited (#2008).
func restCapCmd(rest []string) error {
if len(rest) < 1 || len(rest) > 2 {
return fmt.Errorf("magpie provider rest-cap <id> [1m|30m|6h|1d|off|default]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
minutes, err := restCapMinutes(rest[1])
if err != nil {
return err
}
if err := provider.SetRestCap(p.ID, minutes); err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
if p.NoFailRest() {
fmt.Printf("%s · a key or account that fails without saying why doesn't rest: the next request asks it again. Out of quota or credit, its key refused or its model not served still rests it; rate limited, at most 30 minutes (magpie's own)\n", p.Name)
} else if p.RestCap > 0 {
fmt.Printf("%s · a key or account that keeps failing sits out at most %s\n", p.Name, restWords(time.Duration(p.RestCap)*time.Minute))
} else {
fmt.Printf("%s · a key or account that keeps failing sits out at most 10 minutes, 30 when rate limited (magpie's own)\n", p.Name)
}
return nil
}
// restCapMinutes reads a rest cap as restCapCmd takes it: as restMinutes
// does, but off (or never) is provider.RestCapOff, no rest after an
// unknown failure, and a cap under a minute is turned away with what to
// set instead, as the first rest is a minute already.
func restCapMinutes(s string) (int, error) {
switch strings.ToLower(strings.TrimSpace(s)) {
case "off", "never", "no":
return provider.RestCapOff, nil
}
if d, err := time.ParseDuration(strings.TrimSpace(s)); err == nil && d > 0 && d < time.Minute {
return 0, fmt.Errorf("the shortest rest cap is 1m, which rests a minute every time, not longer; off doesn't rest after an unknown failure at all")
}
return restMinutes(s)
}
// restMinutes reads a rest as quotaRestCmd takes it: default (0), a
// number of minutes, a Go duration (90m, 6h) or a number of days (7d).
func restMinutes(s string) (int, error) {
s = strings.ToLower(strings.TrimSpace(s))
switch s {
case "default", "off", "none", "-", "0":
return 0, nil
}
if n, err := strconv.Atoi(s); err == nil {
return n, nil
}
if days, ok := strings.CutSuffix(s, "d"); ok {
if n, err := strconv.Atoi(days); err == nil {
return n * 24 * 60, nil
}
}
d, err := time.ParseDuration(s)
if err != nil || d < time.Minute {
return 0, fmt.Errorf("a rest is minutes, or as 30m, 6h or 7d, or default, not %q", s)
}
return int(d / time.Minute), nil
}
// restWords is a rest as a person says it: 7 days, 6 hours, 90 minutes.
func restWords(d time.Duration) string {
switch {
case d%(24*time.Hour) == 0:
return plural(int(d/(24*time.Hour)), "day")
case d%time.Hour == 0:
return plural(int(d/time.Hour), "hour")
}
return plural(int(d/time.Minute), "minute")
}
// printMoved says which agents a change moved off models it stopped
// serving (agent.Reseat).
func printMoved(moved []agent.Move) {
for _, m := range moved {
if m.Error != "" {
fmt.Println("!", m.String())
continue
}
fmt.Println(green.Render("✓"), "moved", m.String())
}
}
// editPicks works out a provider's picks from `magpie provider models <id>
// args…`: plain ids replace them, all (or -) gives the default back, and
// +id / -id add one to or take one out of the models exposed now, so a
// user adding a model keeps the rest (MOMO on Discord: 35 exposed → 8).
func editPicks(p provider.Provider, args []string) ([]string, error) {
if len(args) == 1 && (args[0] == "-" || args[0] == "all") {
return nil, nil
}
edits := 0
for _, a := range args {
if len(a) > 1 && (a[0] == '+' || a[0] == '-') {
edits++
}
}
if edits == 0 {
return slices.Clone(args), nil
}
if edits != len(args) {
return nil, fmt.Errorf("give either the whole list (magpie provider models %s a b c) or only changes (+a -b), not both", p.ID)
}
picks := slices.Clone(p.Models)
if len(picks) == 0 {
// no picks yet: the change is to the models exposed by default
for _, m := range p.Exposed() {
picks = append(picks, m.ID)
}
}
for _, a := range args {
id := strings.TrimPrefix(a[1:], p.ID+"/")
if a[0] == '+' {
if !slices.Contains(picks, id) {
picks = append(picks, id)
}
continue
}
i := slices.Index(picks, id)
if i < 0 {
return nil, fmt.Errorf("%s/%s isn't exposed, so there is nothing to take out", p.ID, id)
}
picks = slices.Delete(picks, i, i+1)
}
if len(picks) == 0 {
// no picks means the default list, not none
return nil, fmt.Errorf("that leaves no model exposed · to serve none of %s's models: magpie provider models %s none; to keep them for routing groups alone: magpie provider listed %s no", p.Name, p.ID, p.ID)
}
return picks, nil
}
// printPicksChange says what a change to a provider's picks did: how many
// models were exposed before and after, and which went or came. A list
// that replaced the old one says so, and how to add one instead.
func printPicksChange(before, after provider.Provider, args []string) {
ids := func(p provider.Provider) []string {
var out []string
for _, m := range p.Exposed() {
out = append(out, m.ID)
}
return out
}
was, now := ids(before), ids(after)
var gone, added []string
for _, id := range was {
if !slices.Contains(now, id) {
gone = append(gone, id)
}
}
for _, id := range now {
if !slices.Contains(was, id) {
added = append(added, id)
}
}
replaced := len(args) > 0 && !strings.HasPrefix(args[0], "+") && !(len(args[0]) > 1 && args[0][0] == '-')
if len(args) == 0 {
replaced = true // provider set models=
}
what := "exposed models"
if replaced && len(after.Models) > 0 {
what = "exposed models replaced"
}
fmt.Println(green.Render("✓"), what+":", len(was), "→", len(now))
list := func(ms []string) string {
if len(ms) > 8 {
return strings.Join(ms[:8], ", ") + fmt.Sprintf(" … %d more", len(ms)-8)
}
return strings.Join(ms, ", ")
}
if len(added) > 0 {
fmt.Println(" ", green.Render("+"), list(added))
}
if len(gone) > 0 {
fmt.Println(" ", amber.Render("-"), list(gone))
}
if replaced && len(gone) > 0 && len(after.Models) > 0 {
fmt.Println(muted.Render(" the ids given are now the whole list · to add one and keep the rest: magpie provider models " + after.ID + " +<model>"))
}
avail := map[string]bool{}
for _, m := range after.Available() {
avail[m.ID] = true
}
for _, id := range added {
if len(avail) > 0 && !avail[id] {
fmt.Println(" ", amber.Render("!"), after.ID+"/"+id, muted.Render("isn't in "+after.Name+"'s list; exposed as given"))
}
}
}
// refreshEveryCmd shows, or sets, how often the gateway fetches a
// provider's list by itself (#2135).
func refreshEveryCmd(rest []string) error {
if len(rest) < 1 || len(rest) > 2 {
return fmt.Errorf("magpie provider refresh-every <id> [30m|6h|1d|off]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
if err := provider.SetRefreshEvery(p.ID, rest[1]); err != nil {
return err
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
if d := p.RefreshInterval(); d > 0 {
fmt.Printf("%s · its model list is fetched by the gateway every %s (magpie serve, or the app, running)\n", p.Name, p.RefreshSchedule())
} else {
fmt.Printf("%s · its model list is fetched only when asked (magpie provider refresh %s, or Fetch models)\n", p.Name, p.ID)
}
return nil
}
// autoIncludeCmd shows, or sets, the rules a provider's newly listed models
// are exposed by (#2135); none clears them.
func autoIncludeCmd(rest []string) error {
if len(rest) < 1 {
return fmt.Errorf("magpie provider auto-include <id> [rule…|none]")
}
p, err := provider.Find(rest[0])
if err != nil {
return err
}
if len(rest) > 1 {
rules := rest[1:]
if len(rules) == 1 && (rules[0] == "none" || rules[0] == "off") {
rules = nil
}
taken, err := provider.SetAutoInclude(p.ID, rules)
if err != nil {
return err
}
if len(taken) > 0 {
fmt.Println(green.Render("+"), "exposed now, as its rules match them:", strings.Join(taken, ", "))
}
if p, err = provider.Find(p.ID); err != nil {
return err
}
}
if len(p.AutoInclude) == 0 {
fmt.Printf("%s · no auto-include rules: a newly listed model is exposed as its picks say\n", p.Name)
return nil
}
fmt.Printf("%s · a newly listed model is exposed when one of these matches its id: %s\n", p.Name, strings.Join(p.AutoInclude, " "))
return nil
}
// patienceArg reads patience=: off, default, or a time up to
// provider.PatienceLongest seconds, as 90, 90s or 2m.
func patienceArg(v string) (int, error) {
v = strings.ToLower(strings.TrimSpace(v))
switch v {
case "off", "no", "none", "0":
return provider.PatienceOff, nil
case "default", "":
return 0, nil
}
d, err := time.ParseDuration(v)
if err != nil {
n, nerr := strconv.Atoi(v)
if nerr != nil {
return 0, fmt.Errorf("patience=off|default|<time, e.g. 2m>, not %q", v)
}
d = time.Duration(n) * time.Second
}
if d == 0 {
return provider.PatienceOff, nil
}
if d < 0 || d > provider.PatienceLongest*time.Second {
return 0, fmt.Errorf("patience is at most %s, not %q", provider.PatienceLongest*time.Second, v)
}
return int((d + time.Second - 1) / time.Second), nil
}