Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package gui
import (
"cmp"
"context"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"slices"
"strconv"
"strings"
"time"
"github.com/yetone/magpie/internal/agent"
"github.com/yetone/magpie/internal/autostart"
"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/update"
"github.com/yetone/magpie/internal/upstream"
)
// The providers page: the vendors the user added, the presets they can add
// with one key, the gateway that fronts them, and who is routed where.
type modelJSON struct {
ID string `json:"id"`
Name string `json:"name"` // the user's name for it, if they gave one
Default string `json:"default,omitempty"` // its own name, when the user gave it another
Plain string `json:"plain,omitempty"` // a remote magpie's model's name there alone, when Name has its provider there after it (catalog.Model's)
Kept []string `json:"kept,omitempty"` // the reasoning levels the user keeps of Efforts, when not all
Efforts []string `json:"efforts,omitempty"`
Given bool `json:"given,omitempty"` // its levels aren't known: Efforts are those it can be given, Kept those it was
// Reasonless: the user said it takes no reasoning ask
// (provider.SetModelReasonless): none of Efforts is kept, and none is sent
Reasonless bool `json:"reasonless,omitempty"`
Images bool `json:"images"` // agents are told it can see images
ImageSet bool `json:"imageSet,omitempty"` // the user said so, rather than its vendor
Own bool `json:"ownImages,omitempty"` // its vendor's answer, which a staged Restore default shows
On bool `json:"on"` // exposed to agents
Best bool `json:"best,omitempty"` // the newest of its family in the list: what Best in family serves (provider.NewestInFamily)
Context int `json:"context,omitempty"` // the window agents are told: the user's, else Listed
Output int `json:"output,omitempty"` // the reply limit agents are told: provider.ReplyLimit within Context (provider.OutputWithin)
Listed int `json:"listed,omitempty"` // its window before the user's: its vendor's list's, else models.dev's
Max int `json:"max,omitempty"` // the most its context may be set to, above Listed
Free bool `json:"free,omitempty"` // costs the subscription nothing
Rate float64 `json:"rate,omitempty"` // the credits a request costs the subscription, as a multiple
RateWas float64 `json:"rateWas,omitempty"` // the rate before a discount running now
API string `json:"api,omitempty"` // the one API the user said it is asked on
Auto []string `json:"auto,omitempty"` // the APIs its vendor's list says it is served on, what Auto asks it on
NoAPI bool `json:"noAPI,omitempty"` // the provider has a URL for none of them: agents aren't offered it (provider.NoAPIFor, #2094)
Same string `json:"same,omitempty"` // the model the user said it is the same as, for the groups magpie finds (#583)
Merge string `json:"merge,omitempty"` // what those groups merge it by when the user says nothing
Kind string `json:"kind,omitempty"` // what the user said it makes: image or video (#1399)
// Desktop is the number Claude Desktop's menu says beside this model
// (gateway.DesktopNumber), so a row of that menu can be matched to its
// provider (#2578): only for a model Claude Desktop, installed here,
// is shown and names after its own catalog, "" for every other.
Desktop string `json:"desktop,omitempty"`
// what it costs, USD per million tokens (#819): the price the user set
// for it, and its list price, its vendor's else its maker's, before the
// provider's price rate
Price *catalog.Price `json:"price,omitempty"`
List *catalog.Price `json:"list,omitempty"`
// RemoteList says the list price is what the other magpie counts the
// model at, as its list told (a Remote magpie's), not models.dev's
RemoteList bool `json:"remoteList,omitempty"`
}
type providerJSON struct {
ID string `json:"id"`
Name string `json:"name"`
Icon string `json:"icon"`
Preset string `json:"preset"`
Host string `json:"host"`
Chat string `json:"chat"`
Responses string `json:"responses"`
Anthropic string `json:"anthropic"`
Gemini string `json:"gemini,omitempty"` // a Gemini API's base (#1346)
Decide string `json:"decide,omitempty"` // a decision API: it only routes groups
Catalog string `json:"catalog"`
Website string `json:"website"`
KeysURL string `json:"keysUrl"`
Headers map[string]string `json:"headers,omitempty"`
// JSON fields added to each request's body (provider.ExtraBody, #1604)
ExtraBody provider.ExtraBody `json:"extraBody,omitempty"`
// headers of the vendor's reply passed on (provider.ReplyHeaders, #4145)
ReplyHeaders []string `json:"replyHeaders,omitempty"`
// the API the user gave a custom provider's Base URL as (BaseAPI)
BaseAPI string `json:"baseAPI,omitempty"`
// the vendor searches the web by itself (provider.Searches)
Searches bool `json:"searches"`
// on the Cline API: its DeepSeek models are served by DeepSeek's own
// API alone and its GLM models by Z.ai's (provider.PinUpstream), which
// only it offers
Cline bool `json:"cline,omitempty"`
PinUpstream bool `json:"pinUpstream"`
// on this machine or the local network, set to go unmasked by
// Settings' redaction (provider.Unredacted)
Unredacted bool `json:"unredacted"`
// a provider the user added whose own HTTPS host's certificate is
// taken as it is (provider.InsecureTLS, #2383); TakesInsecureTLS: it
// may be, being the user's own and not a preset's or a sign-in's
InsecureTLS bool `json:"insecureTLS"`
TakesInsecureTLS bool `json:"takesInsecureTLS"`
// asked as usual after a quota refusal or a 429, never set aside for
// it (provider.LimitRestOff)
LimitRestOff bool `json:"limitRestOff"`
// Codex's compaction asked of it as Codex sent it, its sealed item
// back as it came (provider.NativeCompaction, #1099); CarriesCompaction: its
// wire can carry it, so the editor offers it
NativeCompaction bool `json:"nativeCompaction"`
CarriesCompaction bool `json:"carriesCompaction,omitempty"`
// requests go with the agent's own User-Agent, not magpie's
// (provider.PassUserAgent, #1851); OwnClient: they go as a client of
// the vendor's own whatever is set (provider.OwnClient), so the
// editor offers no such choice
PassUserAgent bool `json:"passUserAgent"`
OwnClient bool `json:"ownClient,omitempty"`
// which header its key goes in on a third-party Anthropic API
// (provider.AuthHeader: "" both, "x-api-key", "bearer"), and whether
// it is one that sends both by default (provider.BothAuth)
AuthHeader string `json:"authHeader"`
BothAuth bool `json:"bothAuth,omitempty"`
// the proxy its requests go through: "" the global one, "direct"
// none, or an address (#237)
Proxy string `json:"proxy"`
// the proxy of each of a subscription's accounts that has one of its
// own, by its name in lower case; the others follow Proxy
AccountProxies map[string]string `json:"accountProxies,omitempty"`
// the models each account or key the user narrowed serves alone, by
// its name in lower case or its key's id (#474); the others serve all
AccountModels map[string][]string `json:"accountModels,omitempty"`
// the usage cap each account the user capped is held at, in percent
// of its windows, by its name in lower case (provider.AccountCaps)
AccountCaps map[string]int `json:"accountCaps,omitempty"`
// the share of a window each account is held at where the user set
// one for that window apart, by the account and then the window's
// capId (provider.AccountWindowCaps); 100 is none on that window
AccountWindowCaps map[string]map[string]int `json:"accountWindowCaps,omitempty"`
// the names the user gave its accounts, by the account in lower
// case (provider.AccountNames, #1515), and the name of the key plan
// each account was found to stand in for (provider.SeatNameOf): the
// name an account has until the user gives it one
AccountNames map[string]string `json:"accountNames,omitempty"`
AccountSeats map[string]string `json:"accountSeats,omitempty"`
// where a custom provider's balance is asked (see provider.Balance)
BalanceURL string `json:"balanceURL,omitempty"`
BalancePath string `json:"balancePath,omitempty"`
BalanceMethod string `json:"balanceMethod,omitempty"`
ModelsURL string `json:"modelsURL,omitempty"`
// an account-wide balance token (provider.BalanceToken): whether the
// vendor takes one, and whether one is saved; never the token itself
BalanceToken struct {
Takes bool `json:"takes"`
Set bool `json:"set"`
} `json:"balanceToken"`
// a StepFun provider's Step Plan windows, told only to a platform
// sign-in: which site's, and whether one is kept
StepPlan *stepPlanJSON `json:"stepPlan,omitempty"`
// a Zhipu or Z.ai key's team, for a team's GLM Coding Plan (#236):
// set, if empty, for those providers alone, which the editor asks it of
ZhipuTeam *provider.ZhipuTeam `json:"zhipuTeam,omitempty"`
// a Volcengine account's access key or a Tencent Cloud account's
// SecretId and SecretKey, which its plan's windows are read with
// (provider.AccessKeyVendor): whether the provider takes one, whose,
// its ID, and whether a Secret is saved; never the Secret itself
AccessKey *accessKeyJSON `json:"accessKey,omitempty"`
// a Google Vertex AI provider's project, location and Google
// credentials, which it is asked with in place of a key: set for it
// alone, which the editor asks them of
Vertex *provider.Vertex `json:"vertex,omitempty"`
// ModelTest is why its models can't each be sent a test request, ""
// when they can (provider.ModelTest): the editor says so on a chip's
// right-click rather than offer no menu
ModelTest string `json:"modelTest,omitempty"`
// TestsAs is the agents a model's test can be asked as
// (provider.TestAs), for a relay that serves only them: the chip's
// right-click offers each, and says why one can't be when it can't
TestsAs map[string]string `json:"testsAs,omitempty"`
// DecideTest is set when its decision models can each be sent a
// System One question (provider.AsksDecideModels): a mixed
// provider's Jev too, beside its conversation models
DecideTest bool `json:"decideTest,omitempty"`
// MarksKinds is set when its models can be said to make images or
// videos (provider.MarksKinds, #1399): a chip's right-click offers it
MarksKinds bool `json:"marksKinds,omitempty"`
// Deciders explicitly identifies decision models for OpenRouter and
// remote magpie. An empty remote list suppresses name-based guessing.
Deciders *[]string `json:"deciders,omitempty"`
Key struct {
Set bool `json:"set"`
Masked string `json:"masked"`
Optional bool `json:"optional"`
} `json:"key"`
// AnonKey is the key Add another key adds when nothing is pasted
// (provider.AnonymousKey: OpenCode Zen's public, #1795), while the
// provider doesn't have it yet
AnonKey string `json:"anonKey,omitempty"`
Ready bool `json:"ready"`
Chosen []string `json:"chosen"` // the user's explicit picks, if any
// Speaks: the APIs a provider of keys has a URL for, which a model's
// own API set in the editor is checked against (NoAPI); none for a
// sign-in, whose models are never left out for it
Speaks []string `json:"speaks,omitempty"`
Fallback []string `json:"fallback"` // where requests go when this one can't take them
Routing string `json:"routing"` // how requests spread over its keys or accounts
Affinity string `json:"affinity"` // how long a conversation stays with who answered it
// Sink: a key or account rate limited with quota left goes to the
// back of the order (provider.Provider.Sink)
Sink bool `json:"sink,omitempty"`
// KeepLogin: magpie keeps Codex or Claude Code signed in to the first
// account rather than moving it on when that runs low (#524)
KeepLogin bool `json:"keepLogin,omitempty"`
// KeepLoginAs: the account it is kept signed in to instead of the
// first, the gateway still trying them in their order
KeepLoginAs string `json:"keepLoginAs,omitempty"`
// SwitchOnly: magpie only moves Codex's own sign-in between its
// accounts, never routing its requests for failover (#1907); on
// Claude's, the accounts are kept to Claude Code's own sign-in and
// serve no request through magpie (myduso on Discord)
SwitchOnly bool `json:"switchOnly,omitempty"`
// CapStop and CapCareful: how its accounts end at their caps
// (plugins#349), set on their own with capstop and capcareful
CapStop bool `json:"capStop,omitempty"`
CapCareful bool `json:"capCareful,omitempty"`
// how many requests each of its keys or accounts has out at once, the
// rest queued: the user's (null: not set), and what its plugin says
// when the user set none (provider.Concurrency)
MaxConcurrency *int `json:"maxConcurrency"`
PluginConcurrency int `json:"pluginConcurrency,omitempty"`
// each key's or account's own limit over it (#892), by its name in
// lower case or its key id; 0 there is none
AccountConcurrency map[string]int `json:"accountConcurrency,omitempty"`
// how many may wait for each key or account, and for how many seconds
// (0: no bound)
QueueLimit int `json:"queueLimit,omitempty"`
QueueWait int `json:"queueWait,omitempty"`
// how many requests each key or account sends the vendor in any
// minute, 0 for no limit (coeo91 on Discord)
MaxRPM int `json:"maxRPM,omitempty"`
// what it charges against the official price, 0 for that (#819)
PriceRate float64 `json:"priceRate,omitempty"`
Models []modelJSON `json:"models"` // everything the vendor lists, exposed ones flagged
Exposed int `json:"exposed"` // how many reach the agents
Draws int `json:"draws,omitempty"` // how many of its models draw images (gateway.Drawers)
DrawIDs []string `json:"drawIds,omitempty"` // those models' ids, listed apart in its editor
// those of them unticked in its editor (provider.HiddenDrawers)
HiddenDrawers []string `json:"hiddenDrawers,omitempty"`
Unlisted bool `json:"unlisted"` // its models serve only through routing groups
NoModels bool `json:"noModels"` // Select none: none of its models served (#1818)
// Best in family: with nothing picked, only the newest model of each
// family it lists is served (provider.Provider.BestInFamily)
BestInFamily bool `json:"bestInFamily"`
// Groups are the routing groups ("group/<id>") each of its models is
// in, by model id: what an unlisted one is still used through, and the
// editor names those in none
Groups map[string][]string `json:"groups,omitempty"`
Off bool `json:"off"` // switched off: kept, but agents get none of its models
Contexts map[string]int `json:"contexts,omitempty"` // the windows the user set, "*" for all its models
Outputs map[string]int `json:"outputs,omitempty"` // the reply limits the user set (provider.OutputsOf)
Compacts map[string]int `json:"compacts,omitempty"` // where Codex and Claude Code compact on its models (provider.CompactsOf)
Fetched *time.Time `json:"fetched,omitempty"` // when the list came from the vendor; the page says how long ago in its language
// ListError is why a plugin's account has only the plugin's defaults
// (provider.ListError): the editor says so under its models
ListError string `json:"listError,omitempty"`
Agents []providerAgent `json:"agents"` // detected agents, current ones flagged
Sponsored bool `json:"sponsored"`
KeyList []provider.KeyInfo `json:"keyList"` // its keys, in the order requests try them
Account *accountJSON `json:"account,omitempty"` // a signed-in agent, see provider.Account
// Move is where a built-in subscription stands with the community
// plugin that can run it (provider.Move): set for those that have one
Move *moveJSON `json:"move,omitempty"`
}
type moveJSON struct {
Package string `json:"package"`
// State is "" (built-in, never moved), "plugin", "back" or "failed";
// a retired built-in's row is its plugin's, "plugin"
State string `json:"state"`
Error string `json:"error,omitempty"`
// Why is a failed move's reason, which the page says in its language
Why *provider.MoveWhy `json:"why,omitempty"`
}
// accessKeyJSON is a provider's account access key as the editor sees
// it: whose ("volcengine", "tencent"), the ID, and whether a Secret is
// saved, never the Secret.
type accessKeyJSON struct {
Vendor string `json:"vendor"`
ID string `json:"id"`
SecretSet bool `json:"secretSet"`
}
// presetAccessKey is whose account access key a preset's plans are read
// with ("volcengine", "tencent", "" for none) and, when only some of its
// regions are such a plan (Tencent Cloud's Token Plan 企业版 beside its
// personal plan and pay as you go, #1574), their ids; nil when all are.
func presetAccessKey(pr provider.PresetDef) (string, []string) {
vendor := provider.AccessKeyVendor(provider.Provider{Chat: pr.Chat, Responses: pr.Responses, Anthropic: pr.Anthropic})
var ids []string
for _, r := range pr.Regions {
if v := provider.AccessKeyVendor(provider.Provider{Chat: r.Chat, Responses: r.Responses, Anthropic: r.Anthropic}); v != "" {
ids = append(ids, r.ID)
if vendor == "" {
vendor = v
}
}
}
if vendor == "" || len(ids) == len(pr.Regions) {
return vendor, nil
}
return vendor, ids
}
// stepPlanJSON: whether a StepFun provider's own platform sign-in is kept,
// and where and how the user gets one
type stepPlanJSON struct {
Site string `json:"site"`
SignedIn bool `json:"signedIn"`
URL string `json:"url"`
Bookmarklet string `json:"bookmarklet"`
}
type accountJSON struct {
provider.Account
Agent string `json:"agent"` // the agent's id
Name string `json:"agentName"` // the agent's name, for "from Codex CLI's sign-in"
Icon string `json:"agentIcon"`
// Logins are the agent's accounts magpie remembers, to switch between
Logins []provider.Login `json:"logins,omitempty"`
// Builtin is a plugin's provider id, for a plugin beside a built-in
// subscription (cursor-plugin's cursor): its plan named as the built-in's
Builtin string `json:"builtin,omitempty"`
// WSL is the distro Claude Code runs in, for a Windows with none of its own
WSL string `json:"wsl,omitempty"`
}
// accountLabel is the name and logo an account is shown with: its agent's,
// the subscription's for one no agent magpie configures, and a plugin's
// provider's for a plugin's sign-in, whose agent is "plugin" (#694 listed a
// removed Qoder as "plugin", with no logo).
func accountLabel(p provider.Provider) (name, icon string) {
a := p.Account
if a == nil {
return p.Name, p.Icon
}
name, icon = a.Agent, "generic"
if a.Agent == "factory" {
// a Factory subscription is magpie's own sign-in, not Droid's
name, icon = "Factory", "factory"
} else if a.Agent == provider.MiMoID {
// a Xiaomi MiMo account, not MiMo Code (the agent "mimo" also names)
name, icon = "Xiaomi MiMo", "mimocode"
} else if a.Agent == provider.ChatGPTAPIID {
// a ChatGPT plan through OpenAI's API, not Codex's backend
name, icon = "ChatGPT API", "openai"
} else if ag, err := agent.Find(a.Agent); err == nil {
name, icon = ag.Name, ag.Icon
} else if a.Agent == "cursor" {
// a Cursor subscription is served by the gateway, not an agent magpie configures
name, icon = "Cursor CLI", "cursor"
} else if a.Agent == "kiro" {
// Kiro's sign-in is magpie's own, kiro-cli's or the Kiro IDE's
name, icon = "Kiro", "kiro-color"
} else if a.Agent == "antigravity" {
name, icon = "Antigravity", "antigravity-color"
} else if a.Agent == provider.WorkBuddyAIID {
// WorkBuddy AI, the international build, isn't an agent magpie configures
name, icon = "WorkBuddy AI", "workbuddy-color"
} else if a.Agent == provider.CommandCodePlanID {
// Command Code's CLI keeps the key its sign-in made
name, icon = "Command Code", "commandcode"
}
if !p.IsPlugin() {
return name, icon
}
if pp, ok := provider.PluginOf(p.ID); ok {
// a plugin's sign-in: named for the provider it signs in to
name, icon = pp.Name, pluginIcon(pp)
if name == "" {
name = p.Name
}
if provider.PluginServes(pp.ID) {
icon = p.Icon // the built-in's, as it was
}
return name, icon
}
// its plugin not listed now: the provider's own name and logo
name, icon = p.Name, p.Icon
if icon == "" {
icon = "generic"
}
return name, icon
}
type providerAgent struct {
ID string `json:"id"`
Name string `json:"name"`
Icon string `json:"icon"`
Current bool `json:"current"` // this agent is on one of this provider's models now
Model string `json:"model,omitempty"`
Group string `json:"group,omitempty"` // through this routing group, one of whose members it is
}
type presetJSON struct {
provider.PresetDef
Added bool `json:"added"`
// ZhipuTeam: a key of it may be on a team's GLM Coding Plan, whose
// organization and project the editor offers to take
ZhipuTeam bool `json:"zhipuTeam,omitempty"`
// AccessKey: a plan whose windows are read with the account's access
// key (Volcengine Ark's, Tencent Cloud's Token Plan 企业版), which the
// editor offers to take; AccessKeyVendor whose, and AccessKeyRegions
// the regions it is asked at when not all of them (presetAccessKey)
AccessKey bool `json:"accessKey,omitempty"`
AccessKeyVendor string `json:"accessKeyVendor,omitempty"`
AccessKeyRegions []string `json:"accessKeyRegions,omitempty"`
// Vertex: it is Google Vertex AI, whose editor asks for a Google Cloud
// project and the Google credentials to sign with, not a key
Vertex bool `json:"vertex,omitempty"`
// OwnClient: its requests go as a client of the vendor's own
// (provider.OwnClient), whatever User-Agent the agent gave
OwnClient bool `json:"ownClient,omitempty"`
// a partner's tagline by language, and the languages it is listed in
Notes map[string]string `json:"notes,omitempty"`
Langs []string `json:"langs,omitempty"`
// New: a partner listed since the add sheet last showed the partners,
// and not added; the add button marks it
New bool `json:"new,omitempty"`
}
type gatewayJSON struct {
URL string `json:"url"`
LAN bool `json:"lan"`
LANURLs []string `json:"lanURLs,omitempty"`
// PublicURL is MAGPIE_PUBLIC_URL when it is among LANURLs: Connect
// starts there until the user picks an address (#1551)
PublicURL string `json:"publicURL,omitempty"`
// LANPublic are those of LANURLs at an internet address, which anyone
// online reaches, not only this network
LANPublic []string `json:"lanPublic,omitempty"`
// OnNetwork: MAGPIE_ADDR puts it beyond loopback (a server, a Docker
// image), so every caller is shown a gateway key, and LAN is true too:
// callers from elsewhere, a container's host among them, need one
OnNetwork bool `json:"onNetwork,omitempty"`
Running bool `json:"running"`
Mine bool `json:"mine"` // this process serves it
Window bool `json:"window"` // the magpie serving it shows its routing
// Version is another magpie's, serving it, and Older says it is older
// than this one: agents' requests are then sent as that version sends
// them, without this one's fixes (#506)
Version string `json:"version,omitempty"`
Older bool `json:"older,omitempty"`
// Pid and Serves are the serving magpie's own: which process it is and
// how it was started, for the Routing page to name the one that is
// routing (#2606)
Pid int `json:"pid,omitempty"`
Serves string `json:"serves,omitempty"`
Models int `json:"models"`
Calls []gateway.Call `json:"calls"`
// Lanes are the keys and accounts with requests out or waiting under
// a limit on requests at once (#892), by provider#keyid or
// provider@account
Lanes map[string]gateway.Lane `json:"lanes,omitempty"`
Groups []gwGroupJSON `json:"groups"` // the catalog's routing groups, listed before the models
Archive archiveJSON `json:"archive"` // the request archive's switch, and where it goes
}
// gwGroupJSON is a routing group as the Gateway view lists it.
type gwGroupJSON struct {
ID string `json:"id"` // group/<id>, what a request names
Name string `json:"name"`
Icons []string `json:"icons"` // its providers', one each
Providers []string `json:"providers"` // their names, in the group's order
// what agents are told of it, as of a model: its reasoning levels,
// whether it takes images (every member does) and the context and
// output its members all hold
Efforts []string `json:"efforts,omitempty"`
Images bool `json:"images,omitempty"`
Context int `json:"context,omitempty"`
Output int `json:"output,omitempty"`
Members []string `json:"members,omitempty"` // the models it sends to, provider/model, in its order
}
type excludedJSON struct {
provider.Exclusion
Name string `json:"agentName"`
Icon string `json:"agentIcon"`
}
type providersJSON struct {
Providers []providerJSON `json:"providers"`
Presets []presetJSON `json:"presets"`
Excluded []excludedJSON `json:"excluded"` // sign-ins magpie found but will not share
Gateway gatewayJSON `json:"gateway"`
// CodexDaemon is the account Codex's background app-server is still
// signed in to after Codex was switched to another; "" when none is
// left behind (provider.CodexDaemonStale).
CodexDaemon string `json:"codexDaemon,omitempty"`
// CodexApp is the account the Codex desktop app is still signed in to
// after Codex was switched to another, until it is quit and opened
// again (provider.CodexAppStale)
CodexApp string `json:"codexApp,omitempty"`
// Plugins are the providers the plugins sign in to, for the add sheet
Plugins []pluginSubJSON `json:"plugins"`
// OnPlugins are the built-in subscriptions moved onto their plugins,
// which the add sheet offers as the plugin's alone
OnPlugins []string `json:"onPlugins,omitempty"`
// Movable are the built-in subscriptions a community plugin can run,
// deprecated in magpie itself: the add sheet marks them so
Movable []string `json:"movable,omitempty"`
// MovesTo is the plugin each of them goes to, for the add sheet's
// offer to install it before signing in
MovesTo map[string]string `json:"movesTo,omitempty"`
// Unmoved are the retired built-ins whose accounts haven't moved onto
// their plugins yet, served by nothing until they do, with why
Unmoved []provider.MoveCandidate `json:"unmoved,omitempty"`
// Moved is the agents the change moved off models it stopped serving
// (agent.Reseat), for the page to say so.
Moved []agent.Move `json:"moved,omitempty"`
// Added and Had: of the keys pasted at once (keys/import), how many
// were new and how many the provider had already.
Added int `json:"added,omitempty"`
Had int `json:"had,omitempty"`
// Removed: of the keys removed at once (keys/remove-many), how many.
Removed int `json:"removed,omitempty"`
// FileError is why providers.json can't be read (provider.FileError):
// the page says so over what is listed, which is then the signed-in
// accounts alone, never "add your first provider".
FileError string `json:"fileError,omitempty"`
// Fetching: accounts' lists are still being asked for
// (provider.FetchingNew); the page asks again until they are in
Fetching bool `json:"fetching,omitempty"`
}
// agentModel is the model an agent is on, as magpie's catalog names it.
func agentModel(a *agent.Agent) string {
if len(a.Fields) == 0 {
return ""
}
return strings.TrimPrefix(a.Fields[0].Get(), "magpie/")
}
// agentUse is what an agent is on now: read once for the page, not again
// for each provider (reading it may ask the agent itself, as Alma's does).
type agentUse struct {
*agent.Agent
pid, model string
group provider.Group
members []provider.Member
inGroup bool
}
func agentUses(agents []*agent.Agent, findGroup func(string) (provider.Group, []provider.Member, bool)) []agentUse {
out := make([]agentUse, 0, len(agents))
for _, a := range agents {
u := agentUse{Agent: a}
v := agentModel(a)
if provider.IsGroupRef(v) {
u.group, u.members, u.inGroup = findGroup(v)
} else if pid, model, ok := strings.Cut(v, "/"); ok {
if _, err := provider.Find(pid); err == nil {
u.pid, u.model = pid, model
}
}
out = append(out, u)
}
return out
}
// presetOwnClient says a provider added from pr goes as a client of its
// vendor's own (provider.OwnClient): OpenCode's, Cline's, Kilo's, another
// magpie.
func presetOwnClient(pr provider.PresetDef) bool {
return provider.Provider{Preset: pr.ID, Chat: pr.Chat, Responses: pr.Responses, Anthropic: pr.Anthropic}.OwnClient()
}
// desktopNumbers are the numbers Claude Desktop's menu says beside the
// models it names after its own catalog (gateway.DesktopNumber), by
// "provider/model": none when Claude Desktop isn't installed, and only for
// the models it is shown (provider.CatalogFor), so no other chip carries
// a number nothing shows (#2578).
func desktopNumbers(agents []agentUse) map[string]string {
if !slices.ContainsFunc(agents, func(u agentUse) bool { return u.Agent != nil && u.ID == "claude-desktop" }) {
return nil
}
shown, _ := provider.CatalogFor("claude-desktop")
out := map[string]string{}
for _, e := range shown {
if n := gateway.DesktopNumber(e); n != "" {
out[e.ID] = n
}
}
return out
}
func providerInfo(p provider.Provider, agents []agentUse) providerJSON {
return providerInfoWith(p, agents, desktopNumbers(agents))
}
// providerInfoWith is providerInfo with the Claude Desktop numbers read
// once for the whole list (desktopNumbers).
func providerInfoWith(p provider.Provider, agents []agentUse, desktop map[string]string) providerJSON {
out := providerJSON{
ID: p.ID, Name: p.Name, Icon: p.Icon, Preset: p.Preset, Host: p.Host(),
Chat: p.Chat, Responses: p.Responses, Anthropic: p.Anthropic, Gemini: p.Gemini, Decide: p.Decide, BaseAPI: p.BaseAPI, ModelTest: p.ModelTest(), TestsAs: p.TestClients(), DecideTest: p.AsksDecideModels(), MarksKinds: p.MarksKinds(),
Catalog: p.Catalog, Website: p.Website, KeysURL: p.KeysURL,
Proxy: p.Proxy, AccountProxies: p.AccountProxies, AccountModels: p.AccountModels, AccountCaps: p.AccountCaps, AccountWindowCaps: p.AccountWindowCaps, AccountNames: p.AccountNames, Headers: p.Headers, ExtraBody: p.ExtraBody, ReplyHeaders: p.ReplyHeaders, Searches: p.Searches, Cline: p.ClinePinnable(), PinUpstream: p.PinUpstream, Unredacted: p.Unredacted, InsecureTLS: p.InsecureTLS, TakesInsecureTLS: p.TakesInsecureTLS(), LimitRestOff: p.LimitRestOff, NativeCompaction: p.NativeCompaction, CarriesCompaction: p.CarriesCompaction(), PassUserAgent: p.PassUserAgent, OwnClient: p.OwnClient(), AuthHeader: p.AuthHeader, BothAuth: p.BothAuth(), BalanceURL: p.BalanceURL, BalancePath: p.BalancePath, BalanceMethod: p.BalanceMethod, ModelsURL: p.ModelsURL,
Ready: p.Ready(), Chosen: p.Picks(), Models: []modelJSON{}, Agents: []providerAgent{},
Fallback: p.Fallback, Routing: p.Routing, Sink: p.Sink, Affinity: p.Affinity, KeepLogin: p.KeepLogin, KeepLoginAs: p.KeepLoginAs, SwitchOnly: p.SwitchOnly, CapStop: p.CapStop, CapCareful: p.CapCareful, Unlisted: p.Unlisted, NoModels: p.ServesNone(), BestInFamily: p.BestInFamily && len(p.Models) == 0 && !p.NoModels, Off: p.Off, Contexts: p.Contexts,
MaxConcurrency: p.MaxConcurrency, PluginConcurrency: p.PluginConcurrency(), PriceRate: p.PriceRate,
AccountConcurrency: p.AccountConcurrency, QueueLimit: p.QueueLimit, QueueWait: p.QueueWait, MaxRPM: p.MaxRPM,
Outputs: provider.OutputsOf(p.ID), Compacts: provider.CompactsOf(p.ID),
}
if p.Account != nil {
for _, r := range p.AccountRefs() {
if s := provider.SeatNameOf(p.ID, r); s != "" {
if out.AccountSeats == nil {
out.AccountSeats = map[string]string{}
}
out.AccountSeats[strings.ToLower(strings.TrimSpace(r))] = s
}
}
}
if out.Fallback == nil {
out.Fallback = []string{}
}
if p.Account == nil {
for _, s := range p.Speaks() {
out.Speaks = append(out.Speaks, string(s))
}
}
if out.Chosen == nil {
out.Chosen = []string{}
}
if pr := provider.Preset(p.Preset); pr != nil {
out.Sponsored = pr.Sponsored
out.Key.Optional = pr.NoKey
}
out.BalanceToken.Takes, out.BalanceToken.Set = provider.TakesBalanceToken(p), p.BalanceToken != ""
if provider.TakesZhipuTeam(p) {
out.ZhipuTeam = &provider.ZhipuTeam{}
if p.ZhipuTeam != nil {
*out.ZhipuTeam = *p.ZhipuTeam
}
}
// a provider of a preset with such a plan among its regions takes one
// wherever it is, the editor showing it at those regions
vendor := provider.AccessKeyVendor(p)
if pr := provider.Preset(p.Preset); vendor == "" && pr != nil {
vendor, _ = presetAccessKey(*pr)
}
if vendor != "" || p.AccessKeyID != "" || p.SecretAccessKey != "" {
out.AccessKey = &accessKeyJSON{Vendor: vendor, ID: p.AccessKeyID, SecretSet: p.SecretAccessKey != ""}
}
if p.IsVertex() {
out.Vertex = &provider.Vertex{}
if p.Vertex != nil {
*out.Vertex = *p.Vertex
}
}
if site := provider.StepFunSite(p); site != "" {
out.StepPlan = &stepPlanJSON{site, provider.StepFunSignedIn(p.ID), provider.StepFunSignInURL(site), provider.StepFunBookmarklet()}
}
out.Key.Set = p.Key != ""
out.Key.Masked = provider.Mask(p.Key)
if provider.BuiltinRetired(p.ID) {
// only its plugin's row is listed now: built-in accounts not moved
// yet are providersJSON.Unmoved's
out.Move = &moveJSON{Package: provider.MovePackage(p.ID), State: provider.MovePlugin}
} else if provider.Movable(p.ID) {
m, _ := provider.MigrationOf(p.ID)
out.Move = &moveJSON{Package: provider.MovePackage(p.ID), State: m.State, Error: m.Err, Why: m.Why}
if m.State == provider.MoveMoving {
out.Move.State = ""
}
}
if anon := p.AnonymousKey(); anon != "" && p.Account == nil && !p.HasKey(anon) {
out.AnonKey = anon
}
out.KeyList = p.KeyList()
if out.KeyList == nil {
out.KeyList = []provider.KeyInfo{}
}
// a key the gateway passes over after a failure says so on its row
restKey := p.RestKeys()
for i, k := range out.KeyList {
if !k.On {
continue
}
key := restKey(k)
if r, ok := keyRestOf(key); ok {
out.KeyList[i].Rest = &provider.KeyRest{Why: r.Why, Status: r.Status, Until: r.Until, Key: key, Probed: r.Probed}
}
}
if !out.Key.Set && p.Ready() {
out.Key.Optional = true
}
for id, gs := range provider.MemberGroups() {
if m, ok := strings.CutPrefix(id, p.ID+"/"); ok {
if out.Groups == nil {
out.Groups = map[string][]string{}
}
out.Groups[m] = gs
}
}
if a := p.Account; a != nil {
out.Account = &accountJSON{Account: *a, Agent: a.Agent}
out.Account.Name, out.Account.Icon = accountLabel(p)
out.Account.Logins = provider.Logins(a.Agent)
if a.Agent == "claude" {
out.Account.WSL = provider.ClaudeInWSL()
}
if pp, ok := provider.PluginOf(p.ID); ok && p.IsPlugin() {
// a plugin's sign-in: the page follows it by the provider's id
out.Account.Agent, out.Account.Builtin = p.ID, pp.ID
out.Account.Logins = provider.Logins(p.ID)
if out.Icon == "" || out.Icon == "generic" {
out.Icon = out.Account.Icon
}
}
}
exposed := map[string]bool{}
for _, m := range p.Exposed() {
exposed[m.ID] = true
}
avail := p.Available()
newest := map[string]bool{}
for _, m := range p.NewestInFamily(avail) {
newest[m.ID] = true
}
seen := map[string]bool{}
names, kept := p.ModelNames(), p.ModelEfforts()
held := settings.Load()
sames := held.ModelSameAs
// a list fetched before magpie kept each model's most: the one Codex
// CLI keeps says it
var most []catalog.Model
if p.Account != nil && p.Account.Agent == "codex" {
most = catalog.Codex()
}
// read once for the list: read for each model, three times over, it
// was most of the Providers page's wait with many models (lml on
// Discord, Windows)
set := settings.Load()
named := func(m catalog.Model, on bool) modelJSON {
images := m.Images || catalog.SeesImages(m.ID)
if m.ImageInput != nil {
images = *m.ImageInput
}
own := images
said, imageSet := provider.ImageOverrideIn(set, p.ID, m.ID)
if imageSet {
images = said
}
window := p.WindowOf(m)
j := modelJSON{ID: m.ID, Name: m.Name, Efforts: provider.EffortsOf(m), On: on, Context: window, Output: provider.OutputWithin(window, p.ReplyLimitIn(m, set)), Listed: provider.ListedWindow(m), Max: m.MaxContext, Free: m.Free, Rate: m.Rate, RateWas: m.RateWas, Images: images, ImageSet: imageSet, Own: own, Best: newest[m.ID]}
if i := slices.IndexFunc(most, func(c catalog.Model) bool { return c.ID == m.ID }); j.Max == 0 && i >= 0 {
j.Max = most[i].MaxContext
}
if n, ok := names[m.ID]; ok {
j.Default = cmp.Or(m.Name, m.ID)
j.Name = n
} else {
j.Plain = m.Plain
}
if api, ok := p.ModelAPI(m.ID); ok {
j.API = string(api)
}
for _, a := range p.ListedAPIs(m.ID) {
if slices.Contains(provider.Protocols, a) {
j.Auto = append(j.Auto, string(a))
}
}
j.NoAPI = p.NoAPIFor(m.ID)
j.Same = sames[p.ID+"/"+m.ID]
j.Kind = p.ModelKind(m.ID)
j.Merge = provider.MergeName(m.ID)
j.Desktop = desktop[p.ID+"/"+m.ID]
if mp, ok := held.ModelPrices[p.ID+"/"+m.ID]; ok {
if pr, bad := mp.Price(); bad == "" {
j.Price = &pr
}
}
if pr, ok := p.ListPrice(m.ID); ok {
j.List, j.RemoteList = &pr, p.RemotePriced(m.ID)
} else if pr, ok := provider.MakerPrice(m.ID); ok {
j.List = &pr
} else if pr, ok := provider.SamePriceIn(held, p.ID, m.ID); ok {
j.List = &pr // the model it is the same as, beside it (#2344)
}
if len(j.Efforts) == 0 {
j.Efforts, j.Given = provider.Levels, true
}
if k, ok := kept[m.ID]; ok {
j.Kept = slices.DeleteFunc(slices.Clone(j.Efforts), func(e string) bool { return !slices.Contains(k, e) })
}
if provider.Reasonless(p.ID, m.ID) {
// none of its levels is kept: each is there to tick again
j.Reasonless, j.Kept = true, nil
}
return j
}
for _, m := range avail {
seen[m.ID] = true
out.Models = append(out.Models, named(m, exposed[m.ID]))
}
// Keep an explicit empty list for remote magpie: the editor must not
// guess that a Jev Router chat model answers System One.
var deciders []string
if p.IsRemoteMagpie() {
deciders = []string{}
}
for _, m := range p.DecisionModels() {
deciders = append(deciders, m.ID)
if !seen[m.ID] {
seen[m.ID] = true
out.Models = append(out.Models, named(m, exposed[m.ID]))
}
}
if deciders != nil {
out.Deciders = &deciders
}
// picks the vendor list does not know go first, so they are visible
for _, m := range p.Exposed() {
if !seen[m.ID] {
out.Models = append([]modelJSON{named(m, true)}, out.Models...)
}
}
out.Exposed = len(exposed)
// its image models aren't among those agents chat with; the editor
// lists them apart, as Settings → Images is where one is picked
for _, m := range gateway.Drawers(p) {
out.DrawIDs = append(out.DrawIDs, m.ID)
}
out.Draws = len(out.DrawIDs)
for _, id := range out.DrawIDs {
if p.DrawerHidden(id) {
out.HiddenDrawers = append(out.HiddenDrawers, id)
}
}
if t, ok := p.Listed(); ok {
out.Fetched = &t
}
out.ListError = p.ListError()
for _, a := range agents {
pa := providerAgent{ID: a.ID, Name: a.Name, Icon: a.Icon, Current: a.pid == p.ID, Model: a.model}
if a.inGroup {
for _, m := range a.members {
if m.Provider.ID == p.ID {
pa.Current, pa.Model, pa.Group = true, m.Model, a.group.Name
break
}
}
}
out.Agents = append(out.Agents, pa)
}
return out
}
// keyRestOf is gateway.RestOf, swapped in tests.
var keyRestOf = gateway.RestOf
func providersState() providersJSON {
// an account signed in since start-up is listed with its vendor's
// models, not magpie's own list of them (#204): asked behind the page,
// which is told so and asks again, never waited for (#541)
provider.FetchNewBehind(8 * time.Second)
agents := agent.Detected()
s := providersJSON{Providers: []providerJSON{}, Presets: []presetJSON{}, Excluded: []excludedJSON{}}
s.OnPlugins = provider.OnPlugins()
s.Movable = provider.MovableIDs()
// a retired built-in whose plugin is installed is the plugin's, moved
// or not: the add sheet signs in to it through the plugin alone
for _, id := range s.Movable {
if _, ok := provider.PluginOf(id); ok && provider.BuiltinRetired(id) && !slices.Contains(s.OnPlugins, id) {
s.OnPlugins = append(s.OnPlugins, id)
}
}
for _, id := range s.Movable {
if s.MovesTo == nil {
s.MovesTo = map[string]string{}
}
s.MovesTo[id] = provider.MovePackage(id)
}
for _, c := range provider.MoveCandidates() {
if provider.BuiltinRetired(c.ID) {
s.Unmoved = append(s.Unmoved, c)
}
}
if err := provider.FileError(); err != nil {
s.FileError = err.Error()
}
hidden := map[string]provider.Provider{}
for _, p := range provider.Hidden() {
hidden[p.ID] = p
}
for _, x := range provider.Excluded() {
e := excludedJSON{Exclusion: x, Name: x.Agent, Icon: "generic"}
if p, ok := hidden[x.Provider]; ok && x.Provider != "" {
// a removed account as its row was named: a plugin's by the
// provider it signs in to, not its agent "plugin" (#694)
e.Name, e.Icon = accountLabel(p)
} else if a, err := agent.Find(x.Agent); err == nil {
e.Name, e.Icon = a.Name, a.Icon
}
s.Excluded = append(s.Excluded, e)
}
findGroup := provider.GroupFinder()
uses := agentUses(agents, findGroup)
desktop := desktopNumbers(uses)
have := map[string]bool{}
for _, p := range provider.All() {
// a preset is added once any provider is its, whatever its id
have[p.ID], have[p.Preset] = true, true
s.Providers = append(s.Providers, providerInfoWith(p, uses, desktop))
}
// partners first, as the add sheet lists them
for _, pa := range provider.Partners() {
s.Presets = append(s.Presets, presetJSON{PresetDef: pa.PresetDef, Added: have[pa.ID], Notes: pa.Notes, Langs: pa.Langs, New: !have[pa.ID] && !provider.PartnerNoticed(pa.ID), OwnClient: presetOwnClient(pa.PresetDef)})
}
for _, pr := range provider.Presets() {
bases := provider.Provider{Chat: pr.Chat, Responses: pr.Responses, Anthropic: pr.Anthropic}
team := provider.TakesZhipuTeam(bases)
vendor, keyRegions := presetAccessKey(pr)
s.Presets = append(s.Presets, presetJSON{PresetDef: pr, Added: have[pr.ID], ZhipuTeam: team, AccessKey: vendor != "", AccessKeyVendor: vendor, AccessKeyRegions: keyRegions, Vertex: pr.ID == provider.VertexPreset, OwnClient: presetOwnClient(pr)})
}
cat := provider.Catalog()
s.Gateway = gatewayJSON{URL: gateway.URL(), OnNetwork: gateway.OnNetwork(), Models: len(cat), Calls: []gateway.Call{}, Groups: []gwGroupJSON{}}
s.Gateway.LAN = settings.Load().LAN || s.Gateway.OnNetwork
if s.Gateway.LAN {
s.Gateway.LANURLs = gateway.LANURLs()
s.Gateway.LANPublic = gateway.PublicURLs(s.Gateway.LANURLs)
if u := gateway.PublicURL(); slices.Contains(s.Gateway.LANURLs, u) {
s.Gateway.PublicURL = u
}
}
for _, e := range cat {
if e.Group == "" {
continue
}
// its lists are [] when empty, never null, which the page can't
// read as a list (#1585)
g := gwGroupJSON{ID: e.ID, Name: e.Name, Icons: append([]string{}, e.Icons...), Providers: []string{}, Efforts: e.Efforts, Images: e.Images, Context: e.Context, Output: e.PublishedOutput()}
if _, ms, ok := findGroup(e.ID); ok {
for _, m := range ms {
if id := m.Provider.ID + "/" + m.Model; !slices.Contains(g.Members, id) {
g.Members = append(g.Members, id)
}
if !slices.Contains(g.Providers, m.Provider.Name) {
g.Providers = append(g.Providers, m.Provider.Name)
}
}
}
s.Gateway.Groups = append(s.Gateway.Groups, g)
}
if gw := served.Load(); gw != nil {
s.Gateway.Running, s.Gateway.Mine, s.Gateway.Window = true, true, true
// the calls without their bodies, which only an opened row reads
// (GET /api/gateway/call)
s.Gateway.Calls = gw.Recent()
for i := range s.Gateway.Calls {
s.Gateway.Calls[i].RequestBody, s.Gateway.Calls[i].ResponseBody = "", ""
}
s.Gateway.Lanes = gw.Lanes()
} else {
o := gateway.ServedBy()
s.Gateway.Running, s.Gateway.Window, s.Gateway.Version = o.Running, o.Window, o.Version
s.Gateway.Older = o.Running && update.Newer(gateway.Version, o.Version)
// the process that is routing, for the Routing page to name it
// (#2606): another magpie on this computer, whose routing this
// console shows through OwnerTrace, and its lanes for the rows
s.Gateway.Pid, s.Gateway.Serves = o.Pid, o.Serves
if o.Running {
if l, ok := gateway.OwnerLanes(); ok {
s.Gateway.Lanes = l
}
}
}
s.Gateway.Archive = archiveState()
s.CodexDaemon = provider.CodexDaemonStale()
s.CodexApp = provider.CodexAppStale()
s.Plugins = pluginSubs()
s.Fetching = provider.FetchingNew()
return s
}
// failMove is fail with why the move failed, for the page to say it in
// its reader's language.
func failMove(rw http.ResponseWriter, err error) {
rw.Header().Set("Content-Type", "application/json")
rw.WriteHeader(http.StatusBadRequest)
_ = json.NewEncoder(rw).Encode(map[string]any{"error": err.Error(), "why": provider.WhyOf(err)})
}
// errRetired answers a move back to a built-in subscription, which magpie
// no longer runs: its plugin does.
var errRetired = errors.New("magpie's built-in subscriptions are retired: their community plugins run them")
// moveProvider and adoptProvider are provider.Move and Adopt, for tests
// to stand in for.
var (
moveProvider = provider.Move
adoptProvider = provider.Adopt
)
// moveContext keeps a move going though the page that asked for it goes
// (closed, reloaded): stopped halfway, a move leaves accounts in neither
// place until it is run again.
func moveContext(r *http.Request) (context.Context, context.CancelFunc) {
return context.WithTimeout(context.WithoutCancel(r.Context()), 10*time.Minute)
}
// appLink hands an app's import link over once something here opens it
// (agent.OpenAppLink); tests stand in for the system's answer.
var appLink = agent.OpenAppLink
func providerRoutes(mux *http.ServeMux, w Windows) {
importAppsRoutes(mux)
pluginRoutes(mux, w)
traceRoutes(mux)
contextRoutesAPI(mux)
tuneRoutes(mux)
groupRoutes(mux)
// how each key's or account's requests stand under its limit on
// requests at once (#892), read every two seconds while a provider's
// rows are shown; empty when the gateway runs elsewhere
mux.HandleFunc("GET /api/lanes", func(rw http.ResponseWriter, r *http.Request) {
lanes := map[string]gateway.Lane{}
if gw := served.Load(); gw != nil {
lanes = gw.Lanes()
} else if l, ok := gateway.OwnerLanes(); ok {
// another magpie on this computer serves the gateway: its lanes
// are the ones to show (the rows read the same wherever it runs)
lanes = l
}
writeJSON(rw, lanes)
})
// what the vendors' own status pages say of the APIs the providers
// call (#971), so a vendor's outage isn't taken for a sign-in or quota
// problem. Asked by the Providers and Usage pages; a page is read at
// most once in upstream.Fresh, and the first look waits a little for it.
mux.HandleFunc("GET /api/upstream", func(rw http.ResponseWriter, r *http.Request) {
of := map[string]string{}
var ids []string
for _, p := range provider.All() {
if v := upstream.VendorOf(p.Chat, p.Responses, p.Anthropic); v != "" {
of[p.ID] = v
if !slices.Contains(ids, v) {
ids = append(ids, v)
}
}
}
writeJSON(rw, map[string]any{"vendors": upstream.Wait(4*time.Second, ids...), "providers": of})
})
mux.HandleFunc("GET /api/providers", func(rw http.ResponseWriter, r *http.Request) {
// ?wait: an account just signed in opens in the editor with its
// vendor's list, worth the wait there (#204)
if r.URL.Query().Has("wait") {
provider.FetchNew(8 * time.Second)
}
// ?last=1: the list kept from the last read, at once (#1519);
// null when none is kept
if r.URL.Query().Get("last") == "1" {
if b, ok := lastKnownProviders(); ok {
rw.Header().Set("Content-Type", "application/json")
rw.Write(b)
} else {
writeJSON(rw, nil)
}
return
}
s := providersState()
writeJSON(rw, s)
keepProviders(s)
})
// Recent-call bodies are read only when their row is opened, not with
// every Providers or Gateway refresh (#1521): forty calls' bodies made
// /api/providers 20 MB. The ring may have moved on by then. ?route= is
// the Routing page's request instead of the ring's number (Fate on
// Discord: a request there is opened to its request and response).
mux.HandleFunc("GET /api/gateway/call", func(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Cache-Control", "no-store")
if gw := served.Load(); gw != nil {
var c gateway.Call
ok := false
if id, err := strconv.ParseUint(r.URL.Query().Get("id"), 10, 64); err == nil {
c, ok = gw.RecentCall(id)
} else if route, err := strconv.ParseInt(r.URL.Query().Get("route"), 10, 64); err == nil {
c, ok = gw.RouteCall(route)
}
if ok {
writeJSON(rw, map[string]any{
"requestBody": c.RequestBody, "responseBody": c.ResponseBody,
"requestTruncated": c.RequestTruncated, "responseTruncated": c.ResponseTruncated,
})
return
}
}
rw.Header().Set("Content-Type", "application/json")
rw.WriteHeader(http.StatusNotFound)
writeJSON(rw, map[string]string{"error": "This request is no longer in the recent calls."})
})
// the order the Providers tab lists them in, which is the order they
// are tried in too (#499)
mux.HandleFunc("POST /api/providers/arrange", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Order []string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.SetOrder(in.Order); err != nil {
fail(rw, err)
return
}
writeJSON(rw, providersState())
})
// a picture for a provider, picked in the editor: kept by content before
// the provider is saved, which then points at it. The page sends it as
// base64 in JSON — the app's web view hands a scheme handler no body for
// a File or Blob, so a picture posted as it is arrived empty — and the
// bytes as they are are still taken.
mux.HandleFunc("POST /api/icons", func(rw http.ResponseWriter, r *http.Request) {
b, err := io.ReadAll(io.LimitReader(r.Body, 2*provider.MaxIcon))
if err != nil {
fail(rw, err)
return
}
if strings.HasPrefix(r.Header.Get("Content-Type"), "application/json") {
var in struct{ Data string }
if err := json.Unmarshal(b, &in); err != nil {
fail(rw, err)
return
}
if b, err = base64.StdEncoding.DecodeString(in.Data); err != nil {
fail(rw, err)
return
}
}
icon, err := provider.StoreIcon(b)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]string{"icon": icon})
})
// the site's own icon, found from the provider's base URL (#12)
mux.HandleFunc("POST /api/icons/favicon", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ URL, Name string }
if err := json.NewDecoder(io.LimitReader(r.Body, 64<<10)).Decode(&in); err != nil {
fail(rw, err)
return
}
icon, err := provider.FaviconFor(r.Context(), in.URL, in.Name)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]string{"icon": icon})
})
mux.HandleFunc("GET /api/icons/{name}", func(rw http.ResponseWriter, r *http.Request) {
// a big picture comes scaled to what the window draws (#909)
f, ctype := provider.IconServed(r.PathValue("name"))
if f == "" {
http.NotFound(rw, r)
return
}
if ctype != "" {
rw.Header().Set("Content-Type", ctype)
}
// an SVG is only ever drawn as an image, never run
rw.Header().Set("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'")
rw.Header().Set("Cache-Control", "max-age=31536000, immutable")
http.ServeFile(rw, r, f)
})
mux.HandleFunc("POST /api/provider/{action}", func(rw http.ResponseWriter, r *http.Request) {
var req struct {
provider.Provider
// Proxy is the proxy its requests go through (#237), "" to
// follow the global one; a save that leaves it out keeps it
Proxy *string `json:"proxy"`
// InsecureTLS is whether the certificate of its own HTTPS
// host is taken unchecked (#2383); a save that leaves it out
// keeps it
InsecureTLS *bool `json:"insecureTLS"`
// LimitRestOff is whether a quota refusal or a 429 leaves it
// asked as usual; a save that leaves it out keeps it
LimitRestOff *bool `json:"limitRestOff"`
// MaxConcurrency is how many requests each of its keys or
// accounts has out at once: a number (0 none), null for what
// its plugin says or none; a save that leaves it out keeps it
MaxConcurrency json.RawMessage `json:"maxConcurrency"`
// QueueLimit and QueueWait are how many may wait for each key
// or account and for how many seconds (#892): numbers, 0 or
// null for no bound; a save that leaves them out keeps them
QueueLimit json.RawMessage `json:"queueLimit"`
QueueWait json.RawMessage `json:"queueWait"`
// MaxRPM is how many requests each key or account sends the
// vendor in any minute: a number, 0 or null for no limit; a
// save that leaves it out keeps it
MaxRPM json.RawMessage `json:"maxRPM"`
// Limit, for accountconcurrency: the account's or key's own
// limit, 0 for none, null for the provider's (#892)
Limit *int `json:"limit"`
// PriceRate is what it charges against the official price
// (#819): a number, null or 0 for none; left out, it is kept
PriceRate json.RawMessage `json:"priceRate"`
AccountOrder []string `json:"accountOrder"`
// New is set by the editor's Add: the provider is one more, never
// one replacing the provider that has its id or name
New bool `json:"new"`
// ClearBalanceToken drops the saved balance token, which a
// blank one in the form otherwise keeps
ClearBalanceToken bool `json:"clearBalanceToken"`
// AccessKeyID is a Volcengine access key's ID or a Tencent
// Cloud SecretId, "" for none; a save that leaves it out keeps
// it. Its Secret (SecretAccessKey, a Tencent SecretKey) is kept
// when sent blank, unless ClearAccessKey drops it.
AccessKeyID *string `json:"accessKeyID"`
ClearAccessKey bool `json:"clearAccessKey"`
// From is the id the provider had: another is a rename
From string `json:"from"`
// CopyOf, with New, is the provider the new one is a copy of
// (#268): its key and what else the form doesn't carry are
// taken from it when left out
CopyOf string `json:"copyOf"`
// Model and ModelName, for name: the name the user gives one
// of its models, "" for its own again
Model string `json:"model"`
ModelName string `json:"modelName"`
// Efforts, for efforts: the reasoning levels it offers, none
// for all it has
Efforts []string `json:"efforts"`
// Images, for images: whether the model takes images. Nil
// gives the vendor's answer back.
Images *bool `json:"images"`
// ModelPrefs, for save: the names, levels and images the
// editor's Names & levels changed, by model id, made with the
// rest of the Save and not a click at a time
ModelPrefs map[string]provider.ModelPref `json:"modelPrefs"`
// Outputs, for save: the reply limits the editor's Max output
// says, by model id, "*" for all (provider.SetModelOutputs); a
// save that leaves it out keeps them
Outputs map[string]int `json:"outputs"`
// Compacts, for save: the thresholds the editor's Compact at
// says, by model id, "*" for all (provider.SetModelCompacts,
// #876); a save that leaves it out keeps them
Compacts map[string]int `json:"compacts"`
// Routing and Affinity, for route, affinity and save: how
// requests spread over its keys or accounts, and how long a
// conversation stays with the one that answered it. The
// editor's Save sends them only when picked there, a save
// that leaves them out keeping them: the Routing page's Stays
// was lost at each Save of the provider's editor, which never
// sent it.
Routing *string `json:"routing"`
Affinity *string `json:"affinity"`
// Sink, for sink and save: whether one rate limited with
// quota left goes to the back (provider.Provider.Sink); a
// save that leaves it out keeps it
Sink *bool `json:"sink"`
// NativeCompaction, for save: Codex's compaction asked of it
// as Codex sent it (provider.Provider.NativeCompaction); a save
// that leaves it out keeps it
NativeCompaction *bool `json:"nativeCompaction"`
// AuthHeader, for save: which header the key goes in on a
// third-party Anthropic API (provider.Provider.AuthHeader); a
// save that leaves it out keeps it, one learned too
AuthHeader *string `json:"authHeader"`
// Test, for test: models to send a request each, in place of
// one per endpoint
Test []string `json:"test"`
// As, for test: the agent the request is asked as
// (provider.TestAs: "codex", "claude-code"), "" as magpie
As string `json:"as"`
// DetectModels, for detect: models to ask on each API, each
// answered on its own, in place of Model
DetectModels []string `json:"detectModels"`
// Picked, for detect with no Model: the models the form has
// picked and not saved yet, one of which each API is asked
// for before the saved picks or the vendor's list (#1545)
Picked []string `json:"picked"`
// Account and Allow, for accountmodels: the account (its name)
// or key (its id) and the models it alone serves, none for all
// the provider's (#474)
Account string `json:"account"`
Allow []string `json:"allow"`
// Cap, for accountcap: the share (1–99) of its windows the
// account is used to at most, 0 for no cap; for windowcap, the
// share of Window alone (1–99, 100 for none on it), 0 to have
// it follow the account's cap
Cap int `json:"cap"`
Window string `json:"window"`
// Alias, for accountname: the account's name of the user's
// own, "" to take it off (#1515)
Alias string `json:"alias"`
// Typed, for test and models: the request carries the editor's
// form, which is tried as it stands before a Save (see typed)
Typed bool `json:"typed"`
// Base, for detect: the base URL typed, asked as each API
// takes it where the form has no URL of that API's own
Base string `json:"base"`
// NoModels, for save: the editor's Select none, kept with no
// model picked (#1818); a save that leaves it out keeps it
NoModels *bool `json:"noModels"`
// BestInFamily, for save: the editor's Best in family, kept
// with no model picked; a save that leaves it out keeps it
BestInFamily *bool `json:"bestInFamily"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
fail(rw, err)
return
}
in := req.Provider
if req.NoModels != nil {
in.NoModels = *req.NoModels
}
if req.BestInFamily != nil {
in.BestInFamily = *req.BestInFamily
}
if req.Routing != nil {
in.Routing = *req.Routing
}
if req.Affinity != nil {
in.Affinity = *req.Affinity
}
if req.Sink != nil {
in.Sink = *req.Sink
}
if req.NativeCompaction != nil {
in.NativeCompaction = *req.NativeCompaction
}
if req.AuthHeader != nil {
in.AuthHeader = *req.AuthHeader
}
var moved []agent.Move
switch r.PathValue("action") {
case "show":
// a signed-in account the user removed, back with its picks
if err := provider.ShowAccount(in.ID); err != nil {
fail(rw, err)
return
}
case "move":
// a built-in subscription's accounts onto its community plugin,
// with the models the editor has picked kept first: a failed
// move says to untick one the plugin doesn't serve, and the
// editor's Try again is pressed with it unticked but not saved
// (noting_ever on X: deep-model unticked, and the move failed
// on it all the same)
if in.Models != nil && !in.NoModels {
var err error
if moved, err = agent.Reseat(func() error { return provider.SetModels(in.ID, in.Models) }); err != nil {
fail(rw, err)
return
}
}
ctx, cancel := moveContext(r)
defer cancel()
if err := moveProvider(ctx, in.ID); err != nil {
failMove(rw, err)
return
}
case "adopt":
// a built-in subscription not signed in to, onto its plugin
// first: the plugin installed, and its sign-in the plugin's
ctx, cancel := moveContext(r)
defer cancel()
if err := adoptProvider(ctx, in.ID); err != nil {
failMove(rw, err)
return
}
case "moveback":
// the built-ins are retired: there is no going back to one
fail(rw, errRetired)
return
case "quiet":
// a removed account's "Add it back" line, dismissed (#116)
if err := provider.QuietAccount(in.ID); err != nil {
fail(rw, err)
return
}
case "tuck", "untuck":
// a removed account hidden from the Add sheet's "Removed from
// magpie" too, or listed there again (#116)
if err := provider.TuckAccount(in.ID, r.PathValue("action") == "tuck"); err != nil {
fail(rw, err)
return
}
case "forget":
// a removed account signed out for good: adding it back
// later signs in afresh rather than bringing it back (#694)
if err := provider.ForgetAccount(in.ID); err != nil {
fail(rw, err)
return
}
case "keychain-retry":
// Try again beside Codex's sign-in the macOS keychain didn't
// give: a refusal kept is dropped and the item read once
// (#2367); its answer, or that the prompt is still up
if err := provider.RetryCodexKeychain(); err != nil {
fail(rw, err)
return
}
case "save":
// a preset needs nothing but the key; a saved provider keeps
// its key when the form left it blank
if pr, err := provider.FromPreset(in.Preset); err == nil && in.Chat == "" && in.Responses == "" && in.Anthropic == "" && in.Gemini == "" {
pr.Key, pr.Models, pr.Fallback, pr.Headers, pr.BalanceToken, pr.Contexts = in.Key, in.Models, in.Fallback, in.Headers, in.BalanceToken, in.Contexts
pr.ZhipuTeam = in.ZhipuTeam
pr.NoModels = in.NoModels
pr.BestInFamily = in.BestInFamily
pr.ExtraBody = in.ExtraBody
pr.ReplyHeaders = in.ReplyHeaders
pr.SecretAccessKey = in.SecretAccessKey
pr.Vertex = in.Vertex
pr.Searches = in.Searches
pr.PinUpstream = in.PinUpstream
pr.Unredacted = in.Unredacted
pr.NativeCompaction = in.NativeCompaction
pr.PassUserAgent = in.PassUserAgent
pr.AuthHeader = in.AuthHeader
// and what its editor sets beside them: how requests spread
// over its keys, how long a conversation stays, the one
// rate limited to the back, Unlisted and each key's proxy.
// A decision-only preset (TypeSafe Jev) has no chat URL, so
// every save of its editor came here, and In order went
// back to Smart (fflake33 on Discord)
pr.Routing, pr.Affinity, pr.Sink = in.Routing, in.Affinity, in.Sink
pr.Unlisted = in.Unlisted
pr.HiddenDrawers = in.HiddenDrawers
pr.AccountProxies = in.AccountProxies
if in.Name != "" {
pr.Name = in.Name
}
if in.ID != "" {
pr.ID = in.ID
}
// a decision API's address the user gave, such as the
// Cloudflare one naming the account
if d := strings.TrimSpace(in.Decide); d != "" && pr.Decide != "" {
pr.Decide = d
}
in = pr
}
// fields the body can't be given are refused, not dropped
// unseen (#1604)
if why := provider.ExtraBodyOK(in.ExtraBody); why != "" {
fail(rw, errors.New(why))
return
}
// and reply headers magpie never passes on (#4145)
if why := provider.ReplyHeadersOK(in.ReplyHeaders); why != "" {
fail(rw, errors.New(why))
return
}
cc, keepCC, err := concurrencyOf(req.MaxConcurrency)
if err != nil {
fail(rw, err)
return
}
in.MaxConcurrency = cc
ql, keepQL, err := queueOf(req.QueueLimit, "queue length")
if err != nil {
fail(rw, err)
return
}
qw, keepQW, err := queueOf(req.QueueWait, "queue wait")
if err != nil {
fail(rw, err)
return
}
if err := provider.CheckQueue(ql, qw); err != nil {
fail(rw, err)
return
}
in.QueueLimit, in.QueueWait = ql, qw
rpm, keepRPM, err := queueOf(req.MaxRPM, "requests a minute")
if err != nil {
fail(rw, err)
return
}
if err := provider.CheckRPM(rpm); err != nil {
fail(rw, err)
return
}
in.MaxRPM = rpm
rate, keepRate, err := priceRateOf(req.PriceRate)
if err != nil {
fail(rw, err)
return
}
in.PriceRate = rate
// many keys pasted into the key field (361 on Discord: a provider
// added with hundreds): the first is the key, the others its
// accounts, as Paste several adds them
var moreKeys []string
if ks := provider.SplitKeys(in.Key); len(ks) > 1 {
saved := req.From
if saved == "" {
saved = in.ID
}
if o, err := provider.Find(saved); req.New || err != nil || o.Key != in.Key {
in.Key, moreKeys = ks[0], ks[1:]
}
}
if req.AccessKeyID != nil {
in.AccessKeyID = strings.TrimSpace(*req.AccessKeyID)
}
in.SecretAccessKey = strings.TrimSpace(in.SecretAccessKey)
var old *provider.Provider
if req.New && in.NativeCompaction && !in.CarriesCompaction() {
fail(rw, fmt.Errorf("%s can't carry Codex's native compaction: only a provider with a Responses API, a ChatGPT account or GitHub Copilot can", cmp.Or(in.Name, in.ID)))
return
}
if req.New {
// a second one of a preset, or a name already in use, is
// added beside the first under the next free id
if req.Proxy != nil {
in.Proxy = *req.Proxy
}
if req.InsecureTLS != nil {
in.InsecureTLS = *req.InsecureTLS
}
if req.LimitRestOff != nil {
in.LimitRestOff = *req.LimitRestOff
}
add := provider.Add
if req.CopyOf != "" {
add = func(p provider.Provider) (string, error) { return provider.AddCopy(p, req.CopyOf) }
}
id, err := add(in)
if err != nil {
fail(rw, err)
return
}
in.ID = id
} else {
// a rename saves the rest under the id it had, then moves it
to := strings.ToLower(strings.TrimSpace(in.ID))
rename := req.From != "" && req.From != to
if rename {
if to == "" || to != provider.Slug(to) {
fail(rw, fmt.Errorf("a provider's id must be lowercase letters, digits and dashes, not %q", in.ID))
return
}
in.ID = req.From
}
old, _ = provider.Find(in.ID)
if req.Proxy != nil {
in.Proxy = *req.Proxy
} else if old != nil {
in.Proxy = old.Proxy
}
if req.InsecureTLS != nil {
in.InsecureTLS = *req.InsecureTLS
} else if old != nil {
in.InsecureTLS = old.InsecureTLS
}
if req.LimitRestOff != nil {
in.LimitRestOff = *req.LimitRestOff
} else if old != nil {
in.LimitRestOff = old.LimitRestOff
}
if keepCC && old != nil {
in.MaxConcurrency = old.MaxConcurrency
}
if keepQL && old != nil {
in.QueueLimit = old.QueueLimit
}
if keepQW && old != nil {
in.QueueWait = old.QueueWait
}
if keepRPM && old != nil {
in.MaxRPM = old.MaxRPM
}
if keepRate && old != nil {
in.PriceRate = old.PriceRate
}
// how long its keys rest out of quota is set in
// providers.json or with `magpie provider quota-rest`,
// which the form doesn't show: kept as it was (#1772)
if in.QuotaRest == 0 && old != nil {
in.QuotaRest = old.QuotaRest
}
// and the time of day they are back, set with `magpie
// provider quota-rest <id> until 08:00` (#2008)
if in.QuotaResetAt == "" && old != nil {
in.QuotaResetAt = old.QuotaResetAt
}
// and the most they sit out while they keep failing, set
// with `magpie provider rest-cap` (#2008)
if in.RestCap == 0 && old != nil {
in.RestCap = old.RestCap
}
// and Codex's requests as sent, set with `magpie provider
// set <id> codex=as-sent` (#1758)
if !in.CodexAsSent && old != nil {
in.CodexAsSent = old.CodexAsSent
}
// and Antigravity's prompt as written, set with `magpie
// provider set antigravity prompt=as-written`
if !in.PromptAsWritten && old != nil {
in.PromptAsWritten = old.PromptAsWritten
}
// and additional_tools taken, set with `magpie provider
// set <id> additional-tools=on` (#2660)
if !in.AdditionalTools && old != nil {
in.AdditionalTools = old.AdditionalTools
}
// and how long a request to it alone is kept while it is
// busy, set with `magpie provider set <id> patience=`
if in.Patience == 0 && old != nil {
in.Patience = old.Patience
}
// each account's own proxy likewise: {} clears them
if in.AccountProxies == nil && old != nil {
in.AccountProxies = old.AccountProxies
}
// each account's own models are set on their own, with
// accountmodels
if old != nil {
in.AccountModels = old.AccountModels
}
// and their usage caps, with accountcap and windowcap, and their
// limits on requests at once, with accountconcurrency
if old != nil {
in.AccountCaps, in.AccountWindowCaps = old.AccountCaps, old.AccountWindowCaps
in.AccountConcurrency = old.AccountConcurrency
in.AccountNames = old.AccountNames // with accountname
}
// the image models unticked in its editor likewise: []
// shows them all (321sssrt on X)
if in.HiddenDrawers == nil && old != nil {
in.HiddenDrawers = old.HiddenDrawers
}
// a Zhipu key's team likewise: {} clears it
if in.ZhipuTeam == nil && old != nil {
in.ZhipuTeam = old.ZhipuTeam
}
// and its extra body fields: {} clears them
if in.ExtraBody == nil && old != nil {
in.ExtraBody = old.ExtraBody
}
// and the reply headers passed on: [] clears them
if in.ReplyHeaders == nil && old != nil {
in.ReplyHeaders = old.ReplyHeaders
}
// Select none likewise, while nothing is picked (#1818)
if req.NoModels == nil && old != nil {
in.NoModels = old.NoModels
}
// and Best in family (normalize drops it under a pick)
if req.BestInFamily == nil && old != nil {
in.BestInFamily = old.BestInFamily
}
// a Volcengine access key likewise: its ID kept when left
// out or sent blank (an editor opened before the key was
// given sends ""), its Secret when sent blank, unless the
// form dropped it (#1821)
if in.AccessKeyID == "" && old != nil && !req.ClearAccessKey {
in.AccessKeyID = old.AccessKeyID
}
if in.SecretAccessKey == "" && old != nil && !req.ClearAccessKey {
in.SecretAccessKey = old.SecretAccessKey
}
// and a Vertex AI provider's project and credentials
if in.Vertex == nil && old != nil {
in.Vertex = old.Vertex
}
if in.Key == "" && old != nil {
in.Key = old.Key
}
if in.BalanceToken == "" && old != nil && !req.ClearBalanceToken {
in.BalanceToken = old.BalanceToken
}
if old != nil {
// the other keys are kept apart, in the Accounts list
in.Keys = old.Keys
// the editor's picks, or as they were
if req.Routing == nil {
in.Routing = old.Routing
}
if req.Affinity == nil {
in.Affinity = old.Affinity
}
if req.Sink == nil {
in.Sink = old.Sink
}
if req.NativeCompaction == nil {
in.NativeCompaction = old.NativeCompaction
}
if req.AuthHeader == nil {
in.AuthHeader = old.AuthHeader
}
// its list's schedule and rules are set on their own, from
// the CLI (#2135)
in.RefreshEvery, in.AutoInclude = old.RefreshEvery, old.AutoInclude
in.KeepLogin = old.KeepLogin // set on its own, with keeplogin
in.KeepLoginAs = old.KeepLoginAs
in.SwitchOnly = old.SwitchOnly
in.CapStop, in.CapCareful = old.CapStop, old.CapCareful // capstop, capcareful
in.Off = old.Off // and this with off and on
if in.Contexts == nil {
in.Contexts = old.Contexts // a save that doesn't say
}
if in.Key == old.Key {
in.KeyName, in.KeyProtocol, in.KeyWeight, in.KeyPlan = old.KeyName, old.KeyProtocol, old.KeyWeight, old.KeyPlan
}
// what the editor doesn't show, set from the CLI or the
// TUI, is kept: its tag, website and key page, and on a
// preset's provider its Balance and Models URLs too,
// which only a custom one's editor has fields for
in.Family = cmp.Or(in.Family, old.Family)
in.Website = cmp.Or(in.Website, old.Website)
in.KeysURL = cmp.Or(in.KeysURL, old.KeysURL)
if provider.Preset(in.Preset) != nil {
in.BalanceURL = cmp.Or(in.BalanceURL, old.BalanceURL)
in.BalancePath = cmp.Or(in.BalancePath, old.BalancePath)
in.BalanceMethod = cmp.Or(in.BalanceMethod, old.BalanceMethod)
in.ModelsURL = cmp.Or(in.ModelsURL, old.ModelsURL)
}
}
// the Base URL's API, as picked in the editor; a save that
// doesn't say keeps it
if in.BaseAPI == "" && old != nil {
in.BaseAPI = old.BaseAPI
}
if in.Icon == "" && old != nil && in.Preset == "" {
in.Icon = old.Icon
}
// native compaction only where the wire carries it: a
// signed-in account is told by the one saved
if in.NativeCompaction && !in.CarriesCompaction() && (old == nil || old.Account == nil || !old.CarriesCompaction()) {
fail(rw, fmt.Errorf("%s can't carry Codex's native compaction: only a provider with a Responses API, a ChatGPT account or GitHub Copilot can", cmp.Or(in.Name, in.ID)))
return
}
if err := provider.Save(in); err != nil {
fail(rw, err)
return
}
if rename {
if _, err := agent.RenameProvider(in.ID, to); err != nil {
fail(rw, err)
return
}
in.ID = to
}
}
if len(moreKeys) > 0 {
// those it has already are passed over, not an error
if added, had, err := provider.AddKeys(in.ID, moreKeys, in.KeyProtocol); err != nil && !(added == 0 && had > 0) {
fail(rw, err)
return
}
}
if len(req.ModelPrefs) > 0 {
if err := provider.SetModelPrefs(in.ID, req.ModelPrefs); err != nil {
fail(rw, err)
return
}
}
provider.ForgetBalances()
if old == nil || old.AccessKeyID != in.AccessKeyID || old.SecretAccessKey != in.SecretAccessKey {
// the plan's windows are read afresh with the new access key
provider.ForgetPlanQuotas()
}
// a new key means a new vendor list is worth a try; keep it short
if p, err := provider.Find(in.ID); err == nil && p.Ready() && (old == nil || old.Key != p.Key) {
ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
p.Fetch(ctx)
cancel()
}
// after the list is fetched: a limit has to name a model it has
if req.Outputs != nil {
if err := provider.SetModelOutputs(in.ID, req.Outputs); err != nil {
fail(rw, err)
return
}
}
if req.Compacts != nil {
if err := provider.SetModelCompacts(in.ID, req.Compacts); err != nil {
fail(rw, err)
return
}
}
case "key":
// the saved key, for the editor's Show button; it never
// leaves this machine (the panel is served on loopback).
// With Account, the key of that id: each of several keys'
// rows copies its own (#1480).
if req.Account != "" {
k, err := provider.KeyOf(in.ID, req.Account)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]string{"key": k})
return
}
p, err := provider.Find(in.ID)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]string{"key": p.Key})
return
case "name":
// the agents' own model lists follow, through catalog.Changed
if err := provider.SetModelName(in.ID+"/"+req.Model, req.ModelName); err != nil {
fail(rw, err)
return
}
case "efforts":
if err := provider.SetModelEfforts(in.ID+"/"+req.Model, req.Efforts); err != nil {
fail(rw, err)
return
}
case "images":
if err := provider.SetModelImage(in.ID+"/"+req.Model, req.Images); err != nil {
fail(rw, err)
return
}
case "arrange":
// Promoting the first row is the same account switch as Make first:
// keep the agents' catalogs in sync with the new primary sign-in.
var err error
moved, err = agent.Reseat(func() error { return provider.SetAccountOrder(in.ID, req.AccountOrder) })
if err != nil {
fail(rw, err)
return
}
agent.SyncCatalogSoon()
case "accountmodels":
if err := provider.SetAccountModels(in.ID, req.Account, req.Allow); err != nil {
fail(rw, err)
return
}
case "accountcap":
if err := provider.SetAccountCap(in.ID, req.Account, req.Cap); err != nil {
fail(rw, err)
return
}
case "accountname":
if err := provider.SetAccountName(in.ID, req.Account, req.Alias); err != nil {
fail(rw, err)
return
}
case "windowcap":
if err := provider.SetWindowCap(in.ID, req.Account, req.Window, req.Cap); err != nil {
fail(rw, err)
return
}
case "accountconcurrency":
if err := provider.SetAccountConcurrency(in.ID, req.Account, req.Limit); err != nil {
fail(rw, err)
return
}
case "route":
if err := provider.SetRouting(in.ID, in.Routing); err != nil {
fail(rw, err)
return
}
case "off", "on":
// switched off, it stays with its keys, but agents are given
// none of its models; the files they keep them in follow,
// through catalog.Changed, and the agents on one of its models
// are moved to another
var err error
if moved, err = agent.Reseat(func() error {
return provider.SetOff(in.ID, r.PathValue("action") == "off")
}); err != nil {
fail(rw, err)
return
}
provider.ForgetBalances()
case "keeplogin":
// Codex or Claude Code stays signed in to the first account, or
// to one of the user's choosing (keepLoginAs), which signs it in
// to that one now, and back to the first when let go (#524)
var err error
moved, err = agent.Reseat(func() error {
if in.KeepLogin && in.KeepLoginAs != "" {
return provider.SetKeepLoginAs(in.ID, in.KeepLoginAs)
}
return provider.SetKeepLogin(in.ID, in.KeepLogin)
})
if err != nil {
fail(rw, err)
return
}
agent.SyncCatalogSoon()
case "switchonly":
// magpie only switches Codex's own sign-in, its requests going
// straight to OpenAI, or routes them for failover again
// (#1907); the agent's config follows at once
if err := provider.SetSwitchOnly(in.ID, in.SwitchOnly); err != nil {
fail(rw, err)
return
}
agent.SyncCatalogSoon()
case "capstop":
// a request ends at the accounts' caps, 429, or goes on to the
// fallbacks (plugins#349)
if err := provider.SetCapStop(in.ID, in.CapStop); err != nil {
fail(rw, err)
return
}
case "capcareful":
// usage read again near a cap, an account held while it can't
// be (plugins#349)
if err := provider.SetCapCareful(in.ID, in.CapCareful); err != nil {
fail(rw, err)
return
}
case "affinity":
if err := provider.SetAffinity(in.ID, in.Affinity); err != nil {
fail(rw, err)
return
}
case "sink":
if err := provider.SetSink(in.ID, in.Sink); err != nil {
fail(rw, err)
return
}
case "delete":
var err error
if moved, err = agent.Reseat(func() error { return provider.Delete(in.ID) }); err != nil {
fail(rw, err)
return
}
case "test":
p, err := provider.Find(in.ID)
if err != nil {
fail(rw, err)
return
}
saved := *p
if req.Typed {
q := typed(*p, in, req.Proxy, req.InsecureTLS)
p = &q
}
if len(req.Test) > 0 {
// an image model's test draws a picture, which takes longer
ctx, cancel := context.WithTimeout(provider.TestAs(r.Context(), req.As), 3*time.Minute)
defer cancel()
writeJSON(rw, map[string]any{"results": p.TestModels(ctx, req.Test)})
return
}
ctx, cancel := context.WithTimeout(provider.TestAs(r.Context(), req.As), 25*time.Second)
defer cancel()
writeJSON(rw, struct {
Results []provider.Result `json:"results"`
Provider providerJSON `json:"provider"`
}{p.Test(ctx), providerInfo(saved, agentUses(agent.Detected(), provider.GroupFinder()))})
return
case "detect":
// which APIs answer at the URL typed (Model, or one from the
// list for each), the form as it stands: a new provider's,
// or a saved one's with its key when none is typed — a copy
// not saved yet with the key of the one it copies (CopyOf),
// as its Add takes it. Nothing is written: the provider is
// only asked, never kept, listed or routed to (#1545).
var p provider.Provider
from := in.ID
if from == "" && req.New {
from = req.CopyOf
}
if from != "" {
saved, err := provider.Find(from)
if err != nil {
fail(rw, err)
return
}
p = *saved
}
p = typed(p, in, req.Proxy, req.InsecureTLS)
if strings.TrimSpace(in.Decide) != "" {
// a decision API is asked its smallest question, at
// POST …/systemone (#647)
ctx, cancel := context.WithTimeout(r.Context(), 25*time.Second)
defer cancel()
writeJSON(rw, map[string]any{"results": []provider.Detection{p.DetectDecide(ctx, req.Model)}})
return
}
if len(req.DetectModels) > 0 {
// model by model, a few at a time (01huadalang: 应该能
// 看出来选择的模型支持情况)
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Minute)
defer cancel()
each, sum, err := p.DetectModels(ctx, req.Base, req.DetectModels)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]any{"results": sum, "models": each})
return
}
ctx, cancel := context.WithTimeout(r.Context(), 25*time.Second)
defer cancel()
got, err := p.Detect(ctx, req.Base, req.Model, req.Picked...)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]any{"results": got})
return
case "balance":
// the editor's check of a balance as it stands in the form,
// before a Save: the saved provider with the form's URL, field,
// headers and token (a blank one keeping the saved)
p, err := provider.Find(in.ID)
if err != nil {
fail(rw, err)
return
}
q := *p
q.BalanceURL, q.BalancePath = strings.TrimSpace(in.BalanceURL), strings.TrimSpace(in.BalancePath)
q.BalanceMethod = in.BalanceMethod
if in.Headers != nil {
q.Headers = in.Headers
}
if in.BalanceToken != "" {
q.BalanceToken = in.BalanceToken
} else if req.ClearBalanceToken {
q.BalanceToken = ""
}
ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
defer cancel()
amount, ok, err := provider.Balance(ctx, q)
out := map[string]any{"ok": ok, "amount": amount}
if err != nil {
out["error"] = err.Error()
}
writeJSON(rw, out)
return
case "unfetch":
// the vendor's list, forgotten until the next Refresh
if err := catalog.SaveLive(in.ID, "", nil); err != nil {
fail(rw, err)
return
}
case "list":
// the vendor's list for the form as it stands, nothing saved:
// the add form's Fetch models, picked from before the provider
// is (#578: 添加供应商的时候,希望添加可以获取全模型的按钮)
var p provider.Provider
if pr, err := provider.FromPreset(in.Preset); err == nil {
p = pr
}
if p.Name == "" {
p.Name = cmp.Or(strings.TrimSpace(in.Name), "the vendor")
}
p = typed(p, in, req.Proxy, req.InsecureTLS)
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
defer cancel()
ms, err := p.List(ctx)
if err != nil {
fail(rw, err)
return
}
type listed struct {
ID string `json:"id"`
Name string `json:"name,omitempty"`
}
out := make([]listed, 0, len(ms))
for _, m := range ms {
x := listed{ID: m.ID}
if m.Name != m.ID {
x.Name = m.Name
}
out = append(out, x)
}
writeJSON(rw, map[string]any{"models": out})
return
case "models":
p, err := provider.Find(in.ID)
if err != nil {
fail(rw, err)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
defer cancel()
ask := *p
if req.Typed {
ask = typed(*p, in, req.Proxy, req.InsecureTLS)
}
ms, dropped, err := ask.Refetch(ctx)
if err != nil {
fail(rw, err)
return
}
// the picks the vendor's list no longer has are gone from
// the saved provider: the editor takes them out of its draft
// too, or its Save wrote them back
if q, err := provider.Find(p.ID); err == nil {
p = q
}
writeJSON(rw, struct {
Count int `json:"count"`
Dropped []string `json:"dropped,omitempty"`
Provider providerJSON `json:"provider"`
}{fetchedCount(*p, len(ms)), dropped, providerInfo(*p, agentUses(agent.Detected(), provider.GroupFinder()))})
return
default:
http.NotFound(rw, r)
return
}
st := providersState()
st.Moved = moved
writeJSON(rw, st)
})
// How much of its allowance each of an agent's accounts has used.
mux.HandleFunc("GET /api/login/usage", func(rw http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 12*time.Second)
defer cancel()
writeJSON(rw, provider.WithCapped(provider.LoginUsage(ctx, r.URL.Query().Get("agent"))))
})
// Switching the account an agent is signed in to, among those magpie
// remembers, and forgetting one.
mux.HandleFunc("POST /api/login/{action}", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Agent, User string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
var change func() error
switch r.PathValue("action") {
case "switch":
change = func() error { return provider.SwitchLogin(in.Agent, in.User) }
case "forget":
change = func() error { return provider.ForgetLogin(in.Agent, in.User) }
case "on", "off":
change = func() error { return provider.SetLoginOn(in.Agent, in.User, r.PathValue("action") == "on") }
default:
http.NotFound(rw, r)
return
}
// the last account signed out or off takes the sign-in's models
// away: the agents on them are moved to others
moved, err := agent.Reseat(change)
if err != nil {
fail(rw, err)
return
}
// an agent on its own models goes through magpie while more of
// its accounts are on, and straight to its vendor again once not
agent.SyncCatalogSoon()
st := providersState()
st.Moved = moved
writeJSON(rw, st)
})
// Codex's background app-server, left on the account before a switch
// or on the model list before a change (the Agents row's Restart):
// restarting it (Codex 0.162's sessions on it reconnect, after a turn
// running, for up to a minute; an older Codex's end), or letting it be.
mux.HandleFunc("POST /api/codex/daemon/{action}", func(rw http.ResponseWriter, r *http.Request) {
switch r.PathValue("action") {
case "restart":
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Minute)
defer cancel()
if err := provider.RestartCodexDaemon(ctx); err != nil {
fail(rw, err)
return
}
agent.CodexDaemonRestarted()
case "dismiss":
provider.DismissCodexDaemon()
case "dismiss-app":
provider.DismissCodexApp()
default:
http.NotFound(rw, r)
return
}
writeJSON(rw, providersState())
})
// The Codex desktop app left on the model list before a change (the
// Agents row's Restart): quit it and open it again.
mux.HandleFunc("POST /api/codex/app/reopen", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Bundle string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
ctx, cancel := context.WithTimeout(r.Context(), time.Minute)
defer cancel()
if err := agent.ReopenCodexApp(ctx, in.Bundle); err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]bool{"ok": true})
})
// A provider's several keys: add one, put one in use, name or remove it.
mux.HandleFunc("POST /api/keys/{action}", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
ID, Key, Name, Ref string
Refs []string
Protocol provider.Protocol
Weight int
Plan string
}
var added, had, removed int
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
var err error
var moved []agent.Move
switch r.PathValue("action") {
case "add":
err = provider.AddKey(in.ID, in.Name, in.Key, in.Protocol)
case "import":
// many keys pasted at once, one a line or comma separated
added, had, err = provider.AddKeys(in.ID, provider.SplitKeys(in.Key), in.Protocol)
case "protocol":
err = provider.SetKeyProtocol(in.ID, in.Ref, in.Protocol)
case "weight":
err = provider.SetKeyWeight(in.ID, in.Ref, in.Weight)
case "plan":
// the plan a key is for (KeyAccount.Plan): its endpoints and
// its models are that plan's
err = provider.SetKeyPlan(in.ID, in.Ref, in.Plan)
case "use":
err = provider.UseKey(in.ID, in.Ref)
case "remove":
// the last key gone, or off, takes the provider's models away
moved, err = agent.Reseat(func() error { return provider.RemoveKey(in.ID, in.Ref) })
case "remove-many":
// the keys picked in a long list, or every dead one, at once
moved, err = agent.Reseat(func() (err error) { removed, err = provider.RemoveKeys(in.ID, in.Refs); return err })
case "rename":
err = provider.RenameKey(in.ID, in.Ref, in.Name)
case "replace":
err = replaceKey(in.ID, in.Ref, in.Key)
case "on", "off":
moved, err = agent.Reseat(func() error { return provider.SetKeyOn(in.ID, in.Ref, r.PathValue("action") == "on") })
default:
http.NotFound(rw, r)
return
}
if err != nil {
fail(rw, err)
return
}
// a key that now takes requests has its models asked for: which
// models a key sees is known only from its own list, and an off
// key's isn't asked (#76), so until then a relay that hands out a
// key per group would send the key nothing, or everything
if a := r.PathValue("action"); a == "add" || a == "import" || a == "on" || a == "plan" {
if p, err := provider.Find(in.ID); err == nil && p.Ready() && (len(p.KeysOn()) > 1 || a == "plan") {
ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
p.Fetch(ctx)
cancel()
}
}
st := providersState()
st.Moved, st.Added, st.Had, st.Removed = moved, added, had, removed
writeJSON(rw, st)
})
// Adding a subscription: magpie opens the vendor's sign-in in the
// browser and the window follows it until the account is in.
mux.HandleFunc("POST /api/signin", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Agent, Site string // Site: ZCode's "zai" or "bigmodel"
// Proxy is the one picked to sign in through, kept as the
// account's (#1663); none picked, the one its requests go through
Proxy *string
User string // the account signed in to again
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
st, err := provider.StartSignInWith(in.Agent, provider.SignInOptions{Site: in.Site, Proxy: in.Proxy, User: in.User})
if err != nil {
fail(rw, err)
return
}
// one that installs a CLI first has no URL yet: the window opens it
// once there is one
writeJSON(rw, signInOpened{st, openError(w, st.URL)})
})
mux.HandleFunc("GET /api/signin/{id}", func(rw http.ResponseWriter, r *http.Request) {
st, ok := provider.SignInStatus(r.PathValue("id"))
if !ok {
http.NotFound(rw, r)
return
}
writeJSON(rw, st)
})
mux.HandleFunc("POST /api/signin/{id}/cancel", func(rw http.ResponseWriter, r *http.Request) {
provider.CancelSignIn(r.PathValue("id"))
rw.WriteHeader(http.StatusNoContent)
})
mux.HandleFunc("POST /api/signin/{id}/callback", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ URL string }
if err := json.NewDecoder(io.LimitReader(r.Body, 16<<10)).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.SubmitSignInCallback(r.PathValue("id"), in.URL); err != nil {
fail(rw, err)
return
}
rw.WriteHeader(http.StatusNoContent)
})
// Accounts brought in from another tool's export (Antigravity's, from
// Antigravity Cockpit, Antigravity Manager, CLIProxyAPI; ChatGPT's and
// Claude's from CLIProxyAPI or the agents' own files), each file's
// text as it is; each checked with the vendor before it is kept.
mux.HandleFunc("POST /api/signin/import", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Agent string
Files []string
}
if err := json.NewDecoder(io.LimitReader(r.Body, 8<<20)).Decode(&in); err != nil {
fail(rw, err)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 3*time.Minute)
defer cancel()
imp := provider.ImportGoogleAccounts
if in.Agent == "codex" || in.Agent == "claude" {
// ChatGPT and Claude sign-ins: CLIProxyAPI's auth files, Codex
// CLI's auth.json, Claude Code's .credentials.json
imp = provider.ImportLogins
} else if in.Agent == "factory" {
// Factory API keys (fk-…), as droid takes FACTORY_API_KEY (#506)
imp = func(ctx context.Context, _ string, files []string) ([]provider.ImportedAccount, error) {
return provider.ImportFactoryKeys(ctx, files)
}
}
// the address a sign-in's browser ended on, pasted here rather than
// in the sign-in's Callback URL field, finishes that sign-in: it is
// no account file, and never goes to the vendor as a token
res, rest := provider.PastedSignIns(in.Files)
if len(rest) > 0 {
more, err := imp(ctx, in.Agent, rest)
if err != nil && len(res) == 0 {
fail(rw, err)
return
}
if err != nil {
more = []provider.ImportedAccount{{Status: "failed", Error: err.Error()}}
}
res = append(res, more...)
}
agent.SyncCatalogSoon()
writeJSON(rw, struct {
Results []provider.ImportedAccount `json:"results"`
Providers providersJSON `json:"providers"`
}{res, providersState()})
})
// StepFun's Step Plan windows: the session the user copied from their
// browser with magpie's bookmarklet, the provider's own (two on one
// site can be two accounts, #2384), on the provider's platform
stepfunOf := func(rw http.ResponseWriter, r *http.Request) (string, string, bool) {
p, err := provider.Find(r.PathValue("id"))
if err != nil || provider.StepFunSite(*p) == "" {
http.NotFound(rw, r)
return "", "", false
}
return p.ID, provider.StepFunSite(*p), true
}
mux.HandleFunc("POST /api/stepfun/{id}/session", func(rw http.ResponseWriter, r *http.Request) {
id, site, ok := stepfunOf(rw, r)
if !ok {
return
}
var in struct{ Text string }
if err := json.NewDecoder(io.LimitReader(r.Body, 64<<10)).Decode(&in); err != nil {
fail(rw, err)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
defer cancel()
if err := provider.SaveStepFunPaste(ctx, id, site, in.Text); err != nil {
fail(rw, err)
return
}
writeJSON(rw, providersState())
})
mux.HandleFunc("POST /api/stepfun/{id}/signout", func(rw http.ResponseWriter, r *http.Request) {
id, _, ok := stepfunOf(rw, r)
if !ok {
return
}
if err := provider.SignOutStepFun(id); err != nil {
fail(rw, err)
return
}
writeJSON(rw, providersState())
})
// the page copies through here first: in the app's window the
// clipboard API is refused or missing, depending on the system
mux.HandleFunc("POST /api/copy", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Text string }
_ = json.NewDecoder(r.Body).Decode(&in)
if in.Text == "" || !w.Copy(in.Text) {
http.Error(rw, "", http.StatusNotImplemented)
return
}
rw.WriteHeader(http.StatusNoContent)
})
// the add sheet counts what it showed of the partners and what was
// opened of them (provider.CountPartner); only listed partners count.
// Those shown are no longer new (provider.NoticePartners).
mux.HandleFunc("POST /api/partner", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
What string
IDs []string
}
_ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
if len(in.IDs) <= provider.MaxPartners {
provider.CountPartner(in.What, in.IDs...)
if in.What == provider.PartnerShown {
provider.NoticePartners(in.IDs...)
}
}
rw.WriteHeader(http.StatusNoContent)
})
mux.HandleFunc("POST /api/open", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ URL string }
_ = json.NewDecoder(r.Body).Decode(&in)
// and System Settings' Login Items, where Open at login is allowed
// again: that one pane, not System Settings' scheme at large
if strings.HasPrefix(in.URL, "https://") || strings.HasPrefix(in.URL, "http://") || strings.HasPrefix(in.URL, agent.CindyScheme) || strings.HasPrefix(in.URL, agent.LodyScheme) || strings.HasPrefix(in.URL, agent.AionUiScheme) || in.URL == autostart.LoginItemsURL {
open := w.OpenURL
// an app's import link is handed over only when something
// here opens it: the system says nothing when nothing does,
// and Add magpie did nothing at all (sungt, 10-29)
app := func(u string) error { return appLink(u, w.OpenURL) }
switch {
case strings.HasPrefix(in.URL, agent.LodyScheme):
// Lody on Linux is run with the link, which xdg-open
// turned away (agent.OpenLody)
open = func(u string) error { return agent.OpenLody(u, app) }
case strings.HasPrefix(in.URL, agent.CindyScheme), strings.HasPrefix(in.URL, agent.AionUiScheme):
open = app
}
// Open again on a sign-in says why it didn't open (#2043)
if err := open(in.URL); err != nil {
fail(rw, err)
return
}
}
rw.WriteHeader(http.StatusNoContent)
})
}
// typed is the saved provider p as the editor's form has it (in), for
// Refresh and Test models before a Save: a key pasted to replace the saved
// one is the one asked with, and the URLs, headers, extra body and proxy
// typed are where and how. Nothing is saved. What the form left blank (the
// key above all) is the saved one's; the provider's other keys are kept. A
// Vertex AI provider's project, location, credentials file and service
// account are the ones typed, spelled as a Save keeps them, unless no
// project is.
func typed(p, in provider.Provider, proxy *string, insecureTLS *bool) provider.Provider {
if k := strings.TrimSpace(in.Key); k != "" && k != p.Key {
p.Key, p.KeyName, p.KeyProtocol, p.KeyWeight, p.KeyPlan = k, "", "", 0, ""
}
if v := in.Vertex.Normal(); v != nil && p.IsVertex() && v.Project != "" {
p.Vertex = v
}
for _, f := range []struct {
to *string
v string
}{{&p.Chat, in.Chat}, {&p.Responses, in.Responses}, {&p.Anthropic, in.Anthropic}, {&p.Gemini, in.Gemini}, {&p.Decide, in.Decide}, {&p.ModelsURL, in.ModelsURL}} {
if v := strings.TrimSpace(f.v); v != "" {
*f.to = v
}
}
if in.Headers != nil {
p.Headers = in.Headers
}
if in.ExtraBody != nil {
p.ExtraBody = in.ExtraBody
}
if proxy != nil {
p.Proxy = *proxy
}
// asked unsaved as it would be saved: Via takes it only when p is the
// user's own (TakesInsecureTLS)
if insecureTLS != nil {
p.InsecureTLS = *insecureTLS
}
return p
}
// queueOf is a save's queueLimit or queueWait: keep when the save left it
// out, 0 for null, else the number.
func queueOf(raw json.RawMessage, what string) (n int, keep bool, err error) {
if len(raw) == 0 {
return 0, true, nil
}
var v *int
if err := json.Unmarshal(raw, &v); err != nil {
return 0, false, fmt.Errorf("the %s must be a whole number, not %s", what, raw)
}
if v == nil {
return 0, false, nil
}
return *v, false, nil
}
// priceRateOf is a save's priceRate: keep when the save left it out, 0
// for null, else the rate.
func priceRateOf(raw json.RawMessage) (r float64, keep bool, err error) {
if len(raw) == 0 {
return 0, true, nil
}
var n *float64
if err := json.Unmarshal(raw, &n); err != nil {
return 0, false, fmt.Errorf("a price rate is a number, like 0.8, not %s", raw)
}
if n == nil {
return 0, false, nil
}
if bad := provider.PriceRateOK(*n); bad != "" {
return 0, false, fmt.Errorf("%s, not %v", bad, *n)
}
return *n, false, nil
}
// concurrencyOf is a save's maxConcurrency: keep when the save left it
// out, nil for null (the plugin's, or none), else the number, 0 for none.
func concurrencyOf(raw json.RawMessage) (n *int, keep bool, err error) {
if len(raw) == 0 {
return nil, true, nil
}
if err := json.Unmarshal(raw, &n); err != nil {
return nil, false, fmt.Errorf("max concurrent requests must be a whole number, not %s", raw)
}
if n != nil && (*n < 0 || *n > 1000) {
return nil, false, fmt.Errorf("max concurrent requests must be from 0 to 1000, not %d", *n)
}
return n, false, nil
}
// fetchedCount is the number of models a refetch says it found: the
// models the editor lists from it, not the vendor's ids. Antigravity lists
// a model once per thinking level, which the editor shows as one model
// with those levels (and Cursor and Devin fold theirs the same way), so
// "Antigravity: 23 models" sat over 17 chips (#2069). The ids counted
// stand when the provider offers none.
func fetchedCount(p provider.Provider, ids int) int {
if n := len(p.Available()); n > 0 {
return n
}
return ids
}