Skip to content

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

saves: a routing group or provider saved answers before the agents' files are synced

yetone71fd92ddf774
diff --git a/internal/agent/sync.go b/internal/agent/sync.go
index 409da3932..cfa3d9083 100644
--- a/internal/agent/sync.go
+++ b/internal/agent/sync.go
@@ -67,6 +67,52 @@ func SyncCatalog() {
}
}
+// soon counts the SyncCatalogSoon rounds not done yet. Not a WaitGroup:
+// a save may start one while a command's end waits for them.
+var soon struct {
+ sync.Mutex
+ n int
+ idle *sync.Cond
+}
+
+func init() { soon.idle = sync.NewCond(&soon.Mutex) }
+
+// SyncCatalogSoon is SyncCatalog behind the caller, which is what
+// catalog.Changed is set to: a group or a provider saved answers at once,
+// and the agents' files follow a moment later. The sync builds every
+// agent's lists and writes the ones that differ. On Windows a file another
+// program holds open refuses the rename over it, and steady.Rename waits
+// half a second on each such file before giving up; in WSL each file is
+// read and written through wsl.exe and \\wsl.localhost. A save that waited
+// on it took seconds now and then on Windows, while an agent was at work
+// (CyberCaius on Discord: 路由组和供应商编辑保存有时候保存会卡很久). A sync
+// already running takes the change in its next round, as SyncCatalog does.
+func SyncCatalogSoon() {
+ soon.Lock()
+ soon.n++
+ soon.Unlock()
+ go func() {
+ defer func() {
+ soon.Lock()
+ if soon.n--; soon.n == 0 {
+ soon.idle.Broadcast()
+ }
+ soon.Unlock()
+ }()
+ SyncCatalog()
+ }()
+}
+
+// SyncCatalogSettled waits for every SyncCatalogSoon round started so far:
+// a command that saved something ends with the agents' files written.
+func SyncCatalogSettled() {
+ soon.Lock()
+ for soon.n > 0 {
+ soon.idle.Wait()
+ }
+ soon.Unlock()
+}
+
// syncJSON rewrites the value at key of a JSON file, if the file has one
// there and it differs: an agent that watches its files isn't told of a
// change that isn't one.
diff --git a/internal/cli/main.go b/internal/cli/main.go
index 68d929ec7..785ae3c04 100644
--- a/internal/cli/main.go
+++ b/internal/cli/main.go
@@ -214,7 +214,22 @@ func runTUI() error {
// tuiRun is tui.Run; a var so tests can stand in for it.
var tuiRun = tui.Run
+// syncAgentsOnChange sets what a catalog change (a provider or group
+// saved, a vendor's list fetched anew) does: the model lists agents keep
+// in files of their own are brought up to date behind the save, which
+// answers without waiting for every agent's files to be written (on
+// Windows, half a second for each one another program holds open).
+func syncAgentsOnChange() { catalog.Changed = agent.SyncCatalogSoon }
+
func run(args []string) error {
+ // a command that saved a provider or a group ends with the agents'
+ // files written, which its save no longer waits for; and a test's run
+ // leaves catalog.Changed as it found it
+ was := catalog.Changed
+ defer func() {
+ agent.SyncCatalogSettled()
+ catalog.Changed = was
+ }()
// before anything is read, moved or started: --help on any command
// prints its usage and does nothing else
if helpAsked(args) {
@@ -266,8 +281,9 @@ func run(args []string) error {
agent.MoveOffAccountIDs()
release()
// a provider added, edited or removed, or a list fetched anew, reaches
- // the model lists agents keep in files of their own
- catalog.Changed = agent.SyncCatalog
+ // the model lists agents keep in files of their own, behind the save
+ // that changed it (agent.SyncCatalogSoon)
+ syncAgentsOnChange()
// a model Claude Code names that magpie doesn't serve goes to the one
// it is set to use for that tier
gateway.StandIn = agent.StandIn
diff --git a/internal/cli/save_sync_behind_test.go b/internal/cli/save_sync_behind_test.go
new file mode 100644
index 000000000..0fc0179e1
--- /dev/null
+++ b/internal/cli/save_sync_behind_test.go
@@ -0,0 +1,130 @@
+//go:build !windows
+
+package cli
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "strings"
+ "syscall"
+ "testing"
+ "time"
+
+ "github.com/yetone/magpie/internal/agent"
+ "github.com/yetone/magpie/internal/catalog"
+ "github.com/yetone/magpie/internal/gui"
+ "github.com/yetone/magpie/internal/provider"
+)
+
+// A routing group or a provider saved answers before the agents' model
+// lists are rewritten. Every save ends in catalog.Changed, which rewrote
+// each agent's files inside the request; on Windows each file an agent
+// holds open cost half a second of retried renames, and a save took
+// seconds now and then while an agent was at work (CyberCaius on Discord:
+// 路由组和供应商编辑保存有时候保存会卡很久才保存成功).
+//
+// The slow sync is made here by Pi's models.json being a FIFO: the sync's
+// read of it waits until the test opens the other end, as a write over a
+// held file waits. The save must answer while it waits, and the sync must
+// still run after.
+func TestSaveAnswersBeforeTheAgentsSync(t *testing.T) {
+ home := t.TempDir()
+ for k, v := range map[string]string{"HOME": home, "USERPROFILE": home,
+ "XDG_CONFIG_HOME": filepath.Join(home, ".config"), "XDG_CACHE_HOME": filepath.Join(home, ".cache"),
+ "XDG_DATA_HOME": filepath.Join(home, ".local", "share"), "PI_CODING_AGENT_DIR": ""} {
+ t.Setenv(k, v)
+ }
+ was := catalog.Changed
+ catalog.Changed = nil
+ t.Cleanup(func() {
+ agent.SyncCatalogSettled()
+ catalog.Changed = was
+ })
+ if err := provider.Save(provider.Provider{ID: "a", Name: "a", Key: "ka",
+ Chat: "http://127.0.0.1:1/v1", Models: []string{"m1", "m2"}}); err != nil {
+ t.Fatal(err)
+ }
+ dir := filepath.Join(home, ".pi", "agent")
+ if err := os.MkdirAll(dir, 0o755); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(dir, "settings.json"), []byte(`{}`), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ fifo := filepath.Join(dir, "models.json")
+ h := gui.Handler(nil, nil)
+ post := func(path, body string) (int, string) {
+ rec := httptest.NewRecorder()
+ h.ServeHTTP(rec, httptest.NewRequest("POST", path, strings.NewReader(body)))
+ return rec.Code, rec.Body.String()
+ }
+
+ syncAgentsOnChange()
+ for _, c := range []struct{ name, path, body string }{
+ {"group", "/api/groups/save", `{"id":"g1","from":"g1","name":"G1","members":["a/m1"]}`},
+ {"provider", "/api/provider/save", `{"id":"a","from":"a","name":"A","key":"ka","chat":"http://127.0.0.1:1/v1","models":["m1"]}`},
+ } {
+ t.Run(c.name, func(t *testing.T) {
+ if err := syscall.Mkfifo(fifo, 0o600); err != nil {
+ t.Fatal(err)
+ }
+ // release opens the other end of the sync's held read, so the
+ // read gets {} and goes on. It waits up to 20s for a reader and
+ // says whether one was there; it never blocks past that, so
+ // nothing outlives the test, and the FIFO is gone after it.
+ released := false
+ release := func() bool {
+ if released {
+ return true
+ }
+ defer os.Remove(fifo)
+ for end := time.Now().Add(20 * time.Second); time.Now().Before(end); time.Sleep(10 * time.Millisecond) {
+ // ENXIO until a reader has it open
+ w, err := os.OpenFile(fifo, os.O_WRONLY|syscall.O_NONBLOCK, 0)
+ if err != nil {
+ continue
+ }
+ // a later read finds no file, as before the hold
+ os.Remove(fifo)
+ w.WriteString(`{}`)
+ w.Close()
+ released = true
+ return true
+ }
+ return false
+ }
+ defer release()
+
+ type answer struct {
+ code int
+ body string
+ }
+ done := make(chan answer, 1)
+ start := time.Now()
+ go func() {
+ code, body := post(c.path, c.body)
+ done <- answer{code, body}
+ }()
+ // generous: a loaded machine answers a save in well under this,
+ // while the held sync never ends until released
+ select {
+ case a := <-done:
+ if a.code != http.StatusOK {
+ t.Fatalf("save: %d %s", a.code, a.body)
+ }
+ case <-time.After(20 * time.Second):
+ held := release()
+ <-done
+ t.Fatalf("the %s save waited %s (sync held: %v): it answers only after the agents' files are written",
+ c.name, time.Since(start).Round(time.Millisecond), held)
+ }
+ // the sync did run, and is held on Pi's models.json
+ if !release() {
+ t.Fatalf("no sync ran after the %s save", c.name)
+ }
+ agent.SyncCatalogSettled()
+ })
+ }
+}
diff --git a/internal/gui/providers.go b/internal/gui/providers.go
index 7413bb6a9..abf9b8444 100644
--- a/internal/gui/providers.go
+++ b/internal/gui/providers.go
@@ -1752,7 +1752,7 @@ func providerRoutes(mux *http.ServeMux, w Windows) {
fail(rw, err)
return
}
- agent.SyncCatalog()
+ agent.SyncCatalogSoon()
case "accountmodels":
if err := provider.SetAccountModels(in.ID, req.Account, req.Allow); err != nil {
fail(rw, err)
@@ -1811,7 +1811,7 @@ func providerRoutes(mux *http.ServeMux, w Windows) {
fail(rw, err)
return
}
- agent.SyncCatalog()
+ agent.SyncCatalogSoon()
case "switchonly":
// magpie only switches Codex's own sign-in, its requests going
// straight to OpenAI, or routes them for failover again
@@ -1820,7 +1820,7 @@ func providerRoutes(mux *http.ServeMux, w Windows) {
fail(rw, err)
return
}
- agent.SyncCatalog()
+ agent.SyncCatalogSoon()
case "affinity":
if err := provider.SetAffinity(in.ID, in.Affinity); err != nil {
fail(rw, err)
@@ -2053,7 +2053,7 @@ func providerRoutes(mux *http.ServeMux, w Windows) {
}
// 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.SyncCatalog()
+ agent.SyncCatalogSoon()
st := providersState()
st.Moved = moved
writeJSON(rw, st)
@@ -2238,7 +2238,7 @@ func providerRoutes(mux *http.ServeMux, w Windows) {
fail(rw, err)
return
}
- agent.SyncCatalog()
+ agent.SyncCatalogSoon()
writeJSON(rw, struct {
Results []provider.ImportedAccount `json:"results"`
Providers providersJSON `json:"providers"`