Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package agent
// An agent a plugin adds (internal/agentplug) is wired as a built-in one
// that keeps its model in a file is: its model field picks among the
// agent's own models and magpie's, and a model through magpie writes the
// model, as the plugin spells it, and the keys the plugin's connect
// returns (where the gateway is, its key). What the user had under every
// key magpie writes is stashed first and put back when magpie steps out,
// so a plugin needs no code for that. The plugin says only where things
// go; magpie does every write, to the one file the plugin names.
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"slices"
"strings"
"github.com/tidwall/gjson"
"github.com/tidwall/jsonc"
"github.com/yetone/magpie/internal/agentplug"
"github.com/yetone/magpie/internal/catalog"
"github.com/yetone/magpie/internal/edit"
"github.com/yetone/magpie/internal/gateway"
"github.com/yetone/magpie/internal/plugin"
"github.com/yetone/magpie/internal/provider"
"github.com/yetone/magpie/internal/usage"
)
func init() {
// the agents plugins add come and go, unlike magpie's own; one whose
// id is a built-in's is the built-in's, which the gateway asks first
usage.PluginAgents = func() []usage.Known {
list, _ := agentplug.List()
out := make([]usage.Known, 0, len(list))
for _, p := range list {
out = append(out, usage.Known{ID: p.Desc.ID, Names: []string{p.Desc.ID}, UA: p.Desc.UA})
}
return out
}
}
// pluggedStash is what magpie keeps of an agent plugin's file while it is
// wired: what was under each key it wrote (absent where there was nothing,
// as the file spells it), the model it wrote, and the key whose value is
// the gateway's key, which says the wiring is still magpie's.
type pluggedStash struct {
Had map[string]string `json:"had"`
Ref string `json:"ref"`
Mark string `json:"mark,omitempty"`
Value string `json:"value,omitempty"`
// Wrote are the strings magpie wrote, by key, for Check to tell
// one changed since
Wrote map[string]string `json:"wrote,omitempty"`
// Spec and Format are the plugin's and its file's, so what the user
// had can be put back with the plugin gone (#3810); a stash written
// before them has neither, and its file's name says its format
Spec string `json:"spec,omitempty"`
Format string `json:"format,omitempty"`
}
// PluginErrors is why an agent a plugin adds isn't listed, by plugin
// spec: its module didn't load, or its id is a built-in agent's.
func PluginErrors() map[string]string {
out := map[string]string{}
home, cfg := homes()
pluggedAgents(home, builtins(home, cfg), out)
return out
}
// PluginAgentOf is the id of the agent the plugin spec adds, "" for none.
func PluginAgentOf(spec string) string {
list, _ := agentplug.List()
for _, a := range list {
if a.Spec == spec {
return a.Desc.ID
}
}
return ""
}
// pluggedAgents are the agents plugins add, but one whose id or alias is
// one of builtin's, which errs (when not nil) says.
func pluggedAgents(home string, builtin []*Agent, errs map[string]string) []*Agent {
list, lerrs := agentplug.List()
for k, v := range lerrs {
if errs != nil {
errs[k] = v
}
}
if len(list) == 0 {
return nil
}
taken := map[string]bool{magpieID: true}
for _, a := range append(builtin, others...) {
taken[a.ID] = true
for _, al := range a.Aliases {
taken[al] = true
}
}
var out []*Agent
for _, p := range list {
if taken[p.Desc.ID] {
if errs != nil {
errs[p.Spec] = fmt.Sprintf("agent id %q is magpie's own agent's", p.Desc.ID)
}
continue
}
out = append(out, plugged(home, p))
}
return out
}
// PluginPath is a path an agent plugin gives, as it reads its config's:
// ~ and $VAR expanded against this user's home.
func PluginPath(p string) string {
home, _ := homes()
return pluggedPath(home, p)
}
// pluggedPath is the file a plugin names, with ~ and $VAR as a shell
// reads them.
func pluggedPath(home, p string) string {
p = os.Expand(p, func(k string) string {
if k == "HOME" {
return home
}
return os.Getenv(k)
})
if p == "~" || strings.HasPrefix(p, "~/") {
p = filepath.Join(home, p[1:])
}
return filepath.Clean(p)
}
// pluggedFile is an agent plugin's file, read and written as its format.
type pluggedFile struct {
path, format string
}
// get is the value at key as a string, for comparing.
func (f pluggedFile) get(key string) (string, bool) {
switch f.format {
case "json":
return edit.GetJSON(f.path, key)
case "yaml":
return edit.GetYAML(f.path, key)
}
return edit.GetEnvFile(f.path, key)
}
// raw is the value at key as the file spells it, to be put back so.
func (f pluggedFile) raw(key string) (string, bool) {
switch f.format {
case "json":
b, err := edit.Read(f.path)
if err != nil || len(b) == 0 {
return "", false
}
r := gjson.GetBytes(jsonc.ToJSONInPlace(b), key)
return r.Raw, r.Exists()
case "yaml":
return edit.GetYAMLText(f.path, key)
}
return edit.GetEnvFile(f.path, key)
}
// back is a value raw read, to be written as it was.
func (f pluggedFile) back(v string) any {
switch f.format {
case "json":
return json.RawMessage(v)
case "yaml":
return edit.YAMLText(v)
}
return v
}
func (f pluggedFile) set(kvs []edit.KV) error {
if len(kvs) == 0 {
return nil
}
switch f.format {
case "json":
return edit.SetJSON(f.path, kvs...)
case "yaml":
return edit.SetYAML(f.path, kvs...)
}
for i, kv := range kvs {
switch v := kv.Value.(type) {
case string:
case nil:
kvs[i].Value = ""
default:
b, _ := json.Marshal(v)
kvs[i].Value = string(b)
}
}
return edit.SetEnvFile(f.path, kvs...)
}
func (f pluggedFile) del(keys []string) error {
if len(keys) == 0 {
return nil
}
switch f.format {
case "json":
return edit.DelJSON(f.path, keys...)
case "yaml":
return edit.DelYAML(f.path, keys...)
}
return edit.DelEnvFile(f.path, keys...)
}
// wired says the agent id's file is still as magpie wired it, by st: the
// gateway's key magpie wrote is there.
func (f pluggedFile) wired(id string, st pluggedStash) bool {
if st.Mark == "" {
return true
}
v, _ := f.get(st.Mark)
return v == st.Value || ourKey(v) || v == gateway.TokenFor(id)
}
// restore puts back what the user had under every key magpie wrote, as st
// stashed it under key, and forgets it.
func (f pluggedFile) restore(key string, st pluggedStash) error {
var del []string
var kvs []edit.KV
for _, k := range sortedKeys(st.Had) {
if v := st.Had[k]; v == "\x00" {
del = append(del, k)
} else {
kvs = append(kvs, edit.KV{Path: k, Value: f.back(v)})
}
}
if err := f.del(del); err != nil {
return err
}
if err := f.set(kvs); err != nil {
return err
}
forget(key)
return nil
}
// plugged is the Agent of a plugin's agent at home.
func plugged(home string, p *agentplug.Agent) *Agent {
d := p.Desc
id := d.ID
f := pluggedFile{pluggedPath(home, d.Config), d.Format}
key := "plugin:" + id + ":" + f.path
at := here(home)
saved := func() (pluggedStash, bool) {
var st pluggedStash
v := stashLoad()[key]
return st, v != "" && json.Unmarshal([]byte(v), &st) == nil
}
save := func(st pluggedStash) {
b, _ := json.Marshal(st)
stash(map[string]string{key: string(b)})
}
// onMagpie: magpie wrote the file, and the gateway's key it wrote is
// still there
onMagpie := func() (pluggedStash, bool) {
st, ok := saved()
return st, ok && f.wired(id, st)
}
restore := func(st pluggedStash) error { return f.restore(key, st) }
// only: the agent picks its model itself among those connect writes
// (#2374), so magpie writes no model, and the switch is its one field
only := d.Model == ""
// wire writes ref and connect's keys, stashing what each key had; a
// connect-only agent's ref is ""
wire := func(ref string) error {
var model map[string]any
var models []map[string]any
for _, m := range magpieModels(id) {
j := map[string]any{"id": m.ID, "name": m.Name, "context": m.Context, "output": m.Output, "images": m.Images, "efforts": m.Efforts}
if j["efforts"] == nil {
j["efforts"] = []string{}
}
// what /v1/models says of it too, by the same names, for an
// agent built on the gateway (cleary5779 on Discord): the APIs
// a request for it goes on untranslated, and what a token
// costs; each left out when not known, never empty or 0
if len(m.Endpoints) > 0 {
j["native_endpoints"] = m.Endpoints
}
if m.Price != nil {
j["pricing"] = catalog.OpenRouterPricing(*m.Price)
}
if m.ID == ref {
model = j
}
models = append(models, j)
}
if model == nil {
model = map[string]any{"id": ref, "name": ref, "context": 0, "output": 0, "images": false, "efforts": []string{}}
}
gk := agentKeyAt(id, at.gw())
in := map[string]any{
"gateway": map[string]any{"url": at.gw(), "v1": at.v1(), "key": gk},
"models": models,
"agent": map[string]any{"id": id, "config": f.path},
}
if !only {
in["model"] = model
}
out, err := p.Connect(in)
if err != nil {
return fmt.Errorf("%s: %w", plugin.Name(p.Spec), err)
}
var kvs []edit.KV
if only {
// nothing written would read as connected all the same
if len(out) == 0 {
return fmt.Errorf("%s: connect returned no keys to write", plugin.Name(p.Spec))
}
} else {
delete(out, d.Model)
kvs = append(kvs, edit.KV{Path: d.Model, Value: d.Prefix + ref})
}
mark, strs := "", map[string]string{}
for _, k := range sortedKeys(out) {
kvs = append(kvs, edit.KV{Path: k, Value: out[k]})
if s, ok := out[k].(string); ok {
strs[k] = s
if s == gk && mark == "" {
mark = k
}
}
}
st, was := onMagpie()
if !was {
st = pluggedStash{Had: map[string]string{}}
}
wrote := map[string]bool{}
for _, kv := range kvs {
wrote[kv.Path] = true
if _, ok := st.Had[kv.Path]; ok {
continue
}
if v, ok := f.raw(kv.Path); ok {
st.Had[kv.Path] = v
} else {
st.Had[kv.Path] = "\x00"
}
}
// a key magpie wrote before that connect no longer returns gets
// what the user had back
var del []string
for _, k := range sortedKeys(st.Had) {
if wrote[k] {
continue
}
if v := st.Had[k]; v == "\x00" {
del = append(del, k)
} else {
kvs = append(kvs, edit.KV{Path: k, Value: f.back(v)})
}
delete(st.Had, k)
}
st.Ref, st.Mark, st.Value, st.Wrote = ref, mark, gk, strs
st.Spec, st.Format = p.Spec, f.format
if err := f.del(del); err != nil {
return err
}
if err := f.set(kvs); err != nil {
return err
}
save(st)
return nil
}
get := func() string {
v, _ := f.get(d.Model)
if st, ok := onMagpie(); ok && v == d.Prefix+st.Ref {
return magpieID + "/" + st.Ref
}
return v
}
icon := pluggedIcon(p)
a := &Agent{
ID: id, Name: d.Name, Icon: icon, Spelled: prefixed,
UA: d.UA,
Bin: d.Bin, Path: f.path,
Plugin: p.Spec,
Notice: func() string { return d.Notice },
Check: func() string {
st, ok := onMagpie()
if !ok {
return ""
}
if v, _ := f.get(d.Model); !only && v != d.Prefix+st.Ref {
return ""
}
var kvs []string
for _, k := range sortedKeys(st.Wrote) {
kvs = append(kvs, k, st.Wrote[k])
}
return wiringOff(d.Name, f.path, f.get, kvs...)
},
ListsModels: only,
Fields: []Field{{
Key: "model", Label: "model",
Get: get,
Set: func(v string) error {
if ref, ok := strings.CutPrefix(v, magpieID+"/"); ok && isMagpie(ref) {
return wire(ref)
}
if st, ok := onMagpie(); ok {
if err := restore(st); err != nil {
return err
}
}
if v == "" {
return f.del([]string{d.Model})
}
return f.set([]edit.KV{{Path: d.Model, Value: v}})
},
Options: func(cur map[string]string) []Option {
return append(ownOptions("", cur["model"]), viaMagpie(id, magpieID+"/")...)
},
}},
// the catalog changed: what connect writes for the model may too
Sync: func() error {
if st, ok := onMagpie(); ok {
if v, _ := f.get(d.Model); only || v == d.Prefix+st.Ref {
return wire(st.Ref)
}
}
return nil
},
Unwire: func() error {
if st, ok := onMagpie(); ok {
return restore(st)
}
return nil
},
}
if only {
// magpie as its provider, on or off: the models are the agent's
// to pick, in the list connect writes
a.Fields = []Field{{
Key: "provider", Label: "provider",
Get: func() string {
if _, ok := onMagpie(); ok {
return magpieID
}
return ""
},
Set: func(v string) error {
if v == magpieID {
return wire("")
}
if st, ok := onMagpie(); ok {
return restore(st)
}
return nil
},
Options: func(map[string]string) []Option {
return []Option{{Value: magpieID, Label: "magpie", Icon: "magpie"}}
},
}}
}
if d.Dir != "" {
a.Dir = pluggedPath(home, d.Dir)
}
return atomic(a, f.path)
}
// pluggedIcon is the picture the plugin gives its agent, else the one the
// plugin market gives the plugin, else magpie's generic one.
func pluggedIcon(p *agentplug.Agent) string {
if ic := provider.PluginOwnIcon(p.Desc.Icon); ic != "" {
return ic
}
if ic := plugin.Icon(p.Spec, p.Desc.ID); ic != "" {
return ic
}
// magpie's glyph for one it has no picture of, not an empty square
return "generic"
}
func sortedKeys[V any](m map[string]V) []string {
out := make([]string, 0, len(m))
for k := range m {
out = append(out, k)
}
slices.Sort(out)
return out
}