Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gateway: a test run fails when any route writes a held request body in place
yetone82fb0702fc43
diff --git a/internal/gateway/fastjson.go b/internal/gateway/fastjson.goindex e5e278e4b..8523f1054 100644--- a/internal/gateway/fastjson.go+++ b/internal/gateway/fastjson.go@@ -115,7 +115,14 @@ func holdBody(ctx context.Context, body []byte) {next := append(slices.Clip(cur), body)heldBodies.list.Store(&next)heldBodies.Unlock()+ var unchanged func()+ if checkHeldBody != nil {+ unchanged = checkHeldBody(body)+ }context.AfterFunc(ctx, func() {+ if unchanged != nil {+ unchanged()+ }heldBodies.Lock()defer heldBodies.Unlock()cur := *heldBodies.list.Load()@@ -129,6 +136,14 @@ func holdBody(ctx context.Context, body []byte) {})}+// checkHeldBody, set by the tests, is handed every body holdBody lists and+// returns what checks, as it is released, that the body was not written+// while held. A decoded value shares a held body's bytes, and what is+// read from it is kept by it (factsOf): a body changed in place would+// change them under their holders, or leave them saying what it no longer+// does, so every route the tests serve checks it never is.+var checkHeldBody func(body []byte) (released func())+// inHeldBody says whether raw lies within a body holdBody holds and is// at least 1/heldShareMost of it. A value kept past its request — a// cache's entry, a remembered signature — keeps the whole body it sharesdiff --git a/internal/gateway/held_unchanged_test.go b/internal/gateway/held_unchanged_test.gonew file mode 100644index 000000000..7bd42cd2d--- /dev/null+++ b/internal/gateway/held_unchanged_test.go@@ -0,0 +1,127 @@+package gateway++import (+ "context"+ "fmt"+ "hash/maphash"+ "os"+ "strings"+ "sync"+ "testing"+ "time"+)++// heldWritten lists the held bodies found written in place when they were+// released, for TestMain to fail the run on, and the guard test to find+// its own in.+var heldWritten struct {+ sync.Mutex+ bodies []string+}++// guardHeldBodies has every body holdBody lists checked, at its release,+// against the bytes it was held with (checkHeldBody).+func guardHeldBodies() {+ seed := maphash.MakeSeed()+ checkHeldBody = func(body []byte) func() {+ sum := maphash.Bytes(seed, body)+ return func() {+ if maphash.Bytes(seed, body) == sum {+ return+ }+ heldWritten.Lock()+ heldWritten.bodies = append(heldWritten.bodies, string(body))+ heldWritten.Unlock()+ }+ }+}++// heldWrittenAfter fails a run in which a held body was written in place.+func heldWrittenAfter(code int) int {+ heldWritten.Lock()+ defer heldWritten.Unlock()+ if len(heldWritten.bodies) == 0 {+ return code+ }+ for _, b := range heldWritten.bodies {+ fmt.Fprintf(os.Stderr, "a request body was written in place while held (holdBody): %.200q\n", b)+ }+ return 1+}++// The guard sees a held body written in place, as any route's would be:+// the bodies decodeJSON shares, and factsOf reads once, must stay as they+// were read.+func TestHeldBodyWrittenIsCaught(t *testing.T) {+ if checkHeldBody == nil {+ t.Fatal("TestMain left held bodies unchecked")+ }+ ctx, done := context.WithCancel(context.Background())+ body := []byte(`{"model":"` + t.Name() + `","messages":[{"role":"user","content":"` + strings.Repeat("a", validMemoMin) + `"}]}`)+ holdBody(ctx, body)+ body[len(body)-10] = 'b'+ done()+ marked := string(body)+ for deadline := time.Now().Add(5 * time.Second); ; {+ heldWritten.Lock()+ i := -1+ for j, b := range heldWritten.bodies {+ if b == marked {+ i = j+ }+ }+ if i >= 0 {+ heldWritten.bodies = append(heldWritten.bodies[:i], heldWritten.bodies[i+1:]...)+ }+ heldWritten.Unlock()+ if i >= 0 {+ break+ }+ if time.Now().After(deadline) {+ t.Fatal("a held body written in place was not caught at its release")+ }+ time.Sleep(time.Millisecond)+ }++ // a body left as it was is not reported+ ctx, done = context.WithCancel(context.Background())+ kept := []byte(`{"model":"` + t.Name() + `-kept","messages":[{"role":"user","content":"` + strings.Repeat("a", validMemoMin) + `"}]}`)+ holdBody(ctx, kept)+ done()+ waitHeldReleased(t, kept)+ heldWritten.Lock()+ defer heldWritten.Unlock()+ for _, b := range heldWritten.bodies {+ if b == string(kept) {+ t.Fatal("a body left unchanged was reported written")+ }+ }+}++// waitHeldReleased waits until body is no longer listed: its release, and+// the check before it, have run.+func waitHeldReleased(t *testing.T, body []byte) {+ t.Helper()+ for deadline := time.Now().Add(5 * time.Second); ; {+ if !sharesBodyListed(body) {+ return+ }+ if time.Now().After(deadline) {+ t.Fatal("a body is still held after its request ended")+ }+ time.Sleep(time.Millisecond)+ }+}++func sharesBodyListed(body []byte) bool {+ l := heldBodies.list.Load()+ if l == nil {+ return false+ }+ for _, b := range *l {+ if &b[0] == &body[0] {+ return true+ }+ }+ return false+}diff --git a/internal/gateway/main_test.go b/internal/gateway/main_test.goindex adb115e74..1ad3c7a7c 100644--- a/internal/gateway/main_test.go+++ b/internal/gateway/main_test.go@@ -116,7 +116,9 @@ func isolatedTests(m *testing.M) (int, error) {// and no rest waits on a reading in the background: it would ask a// test's fake upstream after the test ended (#2036, CodeAlex52)awaitAllowance = func(context.Context, string, string) bool { return false }- return m.Run(), nil+ // no route writes a request body in place while it is held+ guardHeldBodies()+ return heldWrittenAfter(m.Run()), nil}// The package's tests run as an isolated test binary: nothing the marker