Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gateway: a resumed Codex subagent goes back on the model it was spawned on
yetone25bf394a72a6
diff --git a/internal/gateway/codex_backend.go b/internal/gateway/codex_backend.goindex 4f80cb16e..b120e5a93 100644--- a/internal/gateway/codex_backend.go+++ b/internal/gateway/codex_backend.go@@ -108,7 +108,13 @@ func (s *Server) codexBackend(w http.ResponseWriter, r *http.Request) {noteAsked(r.Context(), model)// a turn of the conversation's own: the model its side calls may// follow (codexFollowTo)- kind := requestCallKind(r.Header, requestSessionMetadata(r.Header, body))+ meta := requestSessionMetadata(r.Header, body)+ kind := requestCallKind(r.Header, meta)+ // a subagent resume_agent brought back on its lead's model goes+ // back on the one it was spawned with (codexResumeTo)+ if to := s.codexResumeTo(r, agentOf(r), kind, model, meta); to != "" {+ body, model = withModel(body, to), to+ }s.codexLeads.saw(r, kind, model)// a thread's title, where Settings sends it (#705) — the request// still on Codex's own model, through its sign-in, when it saysdiff --git a/internal/gateway/codex_resume.go b/internal/gateway/codex_resume.gonew file mode 100644index 000000000..52fd6ea5f--- /dev/null+++ b/internal/gateway/codex_resume.go@@ -0,0 +1,170 @@+package gateway++import (+ "encoding/json"+ "net/http"+ "os"+ "path/filepath"+ "sort"+ "strings"+ "sync"+ "time"++ "github.com/yetone/magpie/internal/edit"+ "github.com/yetone/magpie/internal/provider"+ "github.com/yetone/magpie/internal/steady"+ "github.com/yetone/magpie/internal/usage"+)++// A Codex subagent resumed with resume_agent went on its lead's model, not+// the one it was spawned on (HoGee_xxl on X). Codex's multi-agent V1, which+// magpie's own models ask for, builds the resumed subagent's config from+// the lead's current turn (codex-rs core/src/agent/child_config.rs,+// build_agent_resume_config → build_agent_shared_config sets config.model+// to turn.model_info().slug), and resume_single_agent_from_rollout+// (core/src/agent/control/spawn.rs) starts the thread on that config+// without reading back the model the thread has stored; neither the+// spawn_agent model nor [agents] default_subagent_model is asked again.+// Multi-agent V2's own reload does put a thread back on its stored model+// (spawn.rs, ensure_v2_agent_loaded: config.model = stored_model), so+// keeping a subagent on the model it was spawned with is Codex's own rule,+// which the V1 path misses.+//+// So the gateway notes the model each Codex subagent thread first asked+// for, and puts a later request of that thread asking for another back on+// it. Within a V1 thread the model never changes otherwise: a subagent has+// no /model. Kept on disk (codex-subagents.json, next to the providers) so+// a subagent resumed after magpie restarted, an update's included, is+// still known. A model set for every subagent (codexSubagentPick) still+// moves the request after this.++// codexSpawnsKept is how many subagent threads are remembered, the latest.+const codexSpawnsKept = 512++// codexSpawnKeep is how long a subagent thread's model is remembered after+// its last request.+const codexSpawnKeep = 30 * 24 * time.Hour++type codexSpawn struct {+ Model string `json:"model"`+ At time.Time `json:"at"`+}++// codexSpawns is the model each Codex subagent thread was spawned on, by+// its thread id.+type codexSpawns struct {+ mu sync.Mutex+ m map[string]codexSpawn+ from string // the file m was read from+}++func codexSpawnsPath() string {+ return filepath.Join(filepath.Dir(provider.Path()), "codex-subagents.json")+}++// codexSubagentThread is the thread a Codex subagent's request is of:+// thread_id in its turn metadata. Codex's session_id is shared by a root+// thread and every subagent under it, so it names a subagent only in a+// Codex from before that, where it differs from the parent thread.+func codexSubagentThread(h http.Header, meta sessionMetadata) string {+ if t := strings.TrimSpace(meta.Thread); t != "" && len(t) <= 128 {+ return t+ }+ parent := strings.TrimSpace(meta.Parent)+ if parent == "" {+ parent = strings.TrimSpace(h.Get("x-codex-parent-thread-id"))+ }+ if s := sessionOf(h); s != "" && parent != "" && s != parent {+ return s+ }+ return ""+}++// codexResumeTo is the model a Codex subagent's request goes on instead+// of asked: the one its thread was spawned on, when it asks for another.+// "" leaves the request as it came: not a Codex subagent's, a thread not+// seen before (noted now), or its own model asked for.+func (s *Server) codexResumeTo(r *http.Request, agent, kind, asked string, meta sessionMetadata) string {+ if agent != "codex" && !fromCodex(r.Header) || asked == "" || usage.PurposeOf(kind) != "kind:collab_spawn" {+ return ""+ }+ thread := codexSubagentThread(r.Header, meta)+ if thread == "" {+ return ""+ }+ return s.codexSpawns.keep(thread, asked)+}++// keep notes asked as thread's model when thread is new, and says the+// model it was spawned on when that isn't asked.+func (c *codexSpawns) keep(thread, asked string) string {+ c.mu.Lock()+ defer c.mu.Unlock()+ path := codexSpawnsPath()+ if c.m == nil || c.from != path {+ c.m, c.from = readCodexSpawns(path), path+ }+ now := time.Now()+ if v, ok := c.m[thread]; ok && now.Sub(v.At) < codexSpawnKeep {+ v.At = now+ c.m[thread] = v+ if v.Model != asked {+ return v.Model+ }+ return ""+ }+ c.m[thread] = codexSpawn{Model: asked, At: now}+ // written as a thread is first seen, once a spawn, not once a request+ c.save(path, now)+ return ""+}++func readCodexSpawns(path string) map[string]codexSpawn {+ m := map[string]codexSpawn{}+ b, err := os.ReadFile(path)+ if err != nil {+ return m+ }+ // a file that can't be read is no memory: each thread is noted afresh+ if decodeJSON(b, &m) != nil {+ return map[string]codexSpawn{}+ }+ return m+}++// save writes the latest threads, only for this user to read. Called+// with c.mu held.+func (c *codexSpawns) save(path string, now time.Time) {+ ids := make([]string, 0, len(c.m))+ for id, v := range c.m {+ if now.Sub(v.At) >= codexSpawnKeep || v.Model == "" {+ delete(c.m, id)+ continue+ }+ ids = append(ids, id)+ }+ if len(ids) > codexSpawnsKept {+ sort.Slice(ids, func(i, j int) bool { return c.m[ids[i]].At.After(c.m[ids[j]].At) })+ for _, id := range ids[codexSpawnsKept:] {+ delete(c.m, id)+ }+ }+ b, err := json.Marshal(c.m)+ if err != nil {+ return+ }+ if os.MkdirAll(filepath.Dir(path), 0o700) != nil {+ return+ }+ path, err = edit.Target(path) // a symlink stays, its target written+ if err != nil {+ return+ }+ tmp := path + ".magpie-tmp"+ if os.WriteFile(tmp, b, 0o600) != nil {+ return+ }+ if steady.Rename(tmp, path) != nil {+ os.Remove(tmp)+ }+}diff --git a/internal/gateway/codex_resume_test.go b/internal/gateway/codex_resume_test.gonew file mode 100644index 000000000..76b2d232a--- /dev/null+++ b/internal/gateway/codex_resume_test.go@@ -0,0 +1,100 @@+package gateway++import (+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/yetone/magpie/internal/provider"+)++const workerAsk = `{"type":"message","role":"user","content":[{"type":"input_text","text":"go on"}]}`++// codexThreadAsks is a request of Codex's as a recent Codex sends it: the+// session_id shared by the root thread and every subagent under it, the+// thread's own id in its turn metadata; a subagent's when parent is set.+func codexThreadAsks(s *Server, model, thread, parent string) *httptest.ResponseRecorder {+ rec := httptest.NewRecorder()+ body := `{"model":"` + model + `","stream":true,"input":[` + workerAsk + `]}`+ req := httptest.NewRequest("POST", CodexPath+"/responses", strings.NewReader(body))+ req.Header.Set("Authorization", "Bearer chatgpt-token")+ req.Header.Set("chatgpt-account-id", "acct-1")+ req.Header.Set("User-Agent", "codex_cli_rs/0.162.1 (Mac OS 26.2.0; arm64)")+ req.Header.Set("session_id", "root-1")+ meta := `{"session_id":"root-1","thread_id":"` + thread + `"`+ if parent != "" {+ req.Header.Set("x-openai-subagent", "collab_spawn")+ req.Header.Set("x-codex-parent-thread-id", parent)+ meta += `,"parent_thread_id":"` + parent + `"`+ }+ req.Header.Set("x-codex-turn-metadata", meta+"}")+ s.Handler().ServeHTTP(rec, req)+ return rec+}++// HoGee_xxl on X: Codex's resume_agent builds the resumed subagent's+// config from its lead's turn (codex-rs core/src/agent/child_config.rs,+// build_agent_resume_config), so a subagent spawned on gpt-6-astra came+// back on the lead's gpt-5.5. It goes back on gpt-6-astra; another+// subagent, and the lead, go on as asked. Remembered across a restart.+func TestCodexResumedSubagentKeepsItsSpawnModel(t *testing.T) {+ up := codexSubagentSetup(t)+ s := New()+ steps := []struct{ model, thread, parent, want string }{+ {"gpt-5.5", "root-1", "", "gpt-5.5"}, // the lead+ {"gpt-6-astra", "worker-1", "root-1", "gpt-6-astra"}, // spawned on astra+ {"gpt-5.5", "worker-2", "root-1", "gpt-5.5"}, // spawned on the lead's+ {"gpt-5.5", "worker-1", "root-1", "gpt-6-astra"}, // resumed on the lead's+ {"gpt-5.5", "root-1", "", "gpt-5.5"}, // the lead's own, untouched+ }+ for i, st := range steps {+ if rec := codexThreadAsks(s, st.model, st.thread, st.parent); rec.Code != 200 {+ t.Fatalf("step %d: %d %s", i, rec.Code, rec.Body.String())+ }+ if got := up.asked(); got[len(got)-1] != st.want {+ t.Fatalf("step %d (%s asking %s) went on %s, want %s", i, st.thread, st.model, got[len(got)-1], st.want)+ }+ }+ // a magpie started afresh still knows worker-1+ if rec := codexThreadAsks(New(), "gpt-5.5", "worker-1", "root-1"); rec.Code != 200 {+ t.Fatalf("after a restart: %d %s", rec.Code, rec.Body.String())+ }+ if got := up.asked(); got[len(got)-1] != "gpt-6-astra" {+ t.Fatalf("after a restart worker-1 went on %s", got[len(got)-1])+ }+}++// A model set for every subagent still holds a resumed one to it.+func TestCodexResumedSubagentHeldToTheModelSet(t *testing.T) {+ up := codexSubagentSetup(t)+ s := New()+ codexThreadAsks(s, "gpt-5.5", "worker-1", "root-1")+ if err := provider.SetCodexSubagentModel("codex/gpt-6-astra"); err != nil {+ t.Fatal(err)+ }+ if rec := codexThreadAsks(s, "gpt-5.5", "worker-1", "root-1"); rec.Code != 200 {+ t.Fatalf("%d %s", rec.Code, rec.Body.String())+ }+ if got := up.asked(); got[len(got)-1] != "gpt-6-astra" {+ t.Fatalf("held subagent went on %s", got[len(got)-1])+ }+}++// A Codex from before session_id was shared names a subagent's thread by+// its session_id; a recent one whose metadata lacks thread_id shares the+// lead's session_id, and is left as asked rather than tied to the lead.+func TestCodexSubagentThreadOf(t *testing.T) {+ h := httptest.NewRequest("POST", "/", nil).Header+ h.Set("session_id", "worker-9")+ h.Set("x-codex-parent-thread-id", "lead-9")+ if got := codexSubagentThread(h, sessionMetadata{}); got != "worker-9" {+ t.Fatalf("older Codex: %q", got)+ }+ h.Set("session_id", "lead-9")+ if got := codexSubagentThread(h, sessionMetadata{}); got != "" {+ t.Fatalf("shared session id taken as the thread: %q", got)+ }+ if got := codexSubagentThread(h, sessionMetadata{Thread: "worker-10"}); got != "worker-10" {+ t.Fatalf("thread_id: %q", got)+ }+}diff --git a/internal/gateway/gateway.go b/internal/gateway/gateway.goindex 2a35e7a23..b2487221d 100644--- a/internal/gateway/gateway.go+++ b/internal/gateway/gateway.go@@ -435,6 +435,9 @@ type Server struct {// codexLeads is the model each Codex conversation's own turns last// went on, for its side calls to follow (codexFollowTo)codexLeads codexLeads+ // codexSpawns is the model each Codex subagent thread was spawned on,+ // which a resumed one goes back on (codexResumeTo)+ codexSpawns codexSpawns// the listener, swapped when the gateway is shared on the network or// taken off it (see Relisten)lnMu sync.Mutexdiff --git a/internal/gateway/session_parent.go b/internal/gateway/session_parent.goindex 98ccd2998..eab7ced8c 100644--- a/internal/gateway/session_parent.go+++ b/internal/gateway/session_parent.go@@ -32,6 +32,7 @@ func isPredictionKind(kind string) bool {// prompts or the rest of the metadata in the trace.type sessionMetadata struct {Turn string `json:"turn_id"`+ Thread string `json:"thread_id"`Source string `json:"thread_source"`Parent string `json:"parent_thread_id"`Forked string `json:"forked_from_thread_id"`@@ -57,6 +58,7 @@ func requestSessionMetadata(h http.Header, body []byte) sessionMetadata {}} else if len(metadata) > 0 {_ = json.Unmarshal(metadata["turn_id"], &m.Turn)+ _ = json.Unmarshal(metadata["thread_id"], &m.Thread)// Compatibility projections used by clients without the full blob._ = json.Unmarshal(metadata["thread_source"], &m.Source)_ = json.Unmarshal(metadata["parent_thread_id"], &m.Parent)