Skip to content

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

provider: Codex's zstd encoder keeps two coders, not one per core, and holds ~9 MB instead of ~80

yetone9b72add51dea
diff --git a/internal/provider/codex_zstd.go b/internal/provider/codex_zstd.go
index 0ba506699..2ca1d7256 100644
--- a/internal/provider/codex_zstd.go
+++ b/internal/provider/codex_zstd.go
@@ -31,11 +31,25 @@ import (
// Codex's codex-rs/http-client/src/request.rs uses
// zstd::stream::encode_all(.., 3), whose unknown-size stream has a 2 MiB
// window. Keep turns within that client envelope too.
-var codexZstd, _ = zstd.NewWriter(nil,
- zstd.WithEncoderLevel(zstd.SpeedDefault),
- zstd.WithEncoderCRC(false),
- zstd.WithWindowSize(2<<20),
-)
+//
+// The encoder keeps one coder per concurrent EncodeAll, GOMAXPROCS by
+// default, and each keeps its history (4 MiB at a 2 MiB window) for the
+// life of the process: 74 MB of a live gateway's 288 MB heap on a 14-core
+// Mac. A 1 MiB turn encodes in about half a millisecond, so two coders in
+// low-memory mode keep up with dozens of agents and hold ~9 MB. Neither
+// option changes the bytes sent.
+var codexZstd = newCodexZstd()
+
+func newCodexZstd() *zstd.Encoder {
+ z, _ := zstd.NewWriter(nil,
+ zstd.WithEncoderLevel(zstd.SpeedDefault),
+ zstd.WithEncoderCRC(false),
+ zstd.WithWindowSize(2<<20),
+ zstd.WithEncoderConcurrency(2),
+ zstd.WithLowerEncoderMem(true),
+ )
+ return z
+}
// codexZstdOff leaves turns plain, for tests alone: the fake backends of
// most of the gateway's and provider's tests read the body as it comes, so
diff --git a/internal/provider/codex_zstd_test.go b/internal/provider/codex_zstd_test.go
index cf3402ada..e5660b3ae 100644
--- a/internal/provider/codex_zstd_test.go
+++ b/internal/provider/codex_zstd_test.go
@@ -11,7 +11,9 @@ import (
"math/rand/v2"
"net/http"
"net/http/httptest"
+ "runtime"
"strings"
+ "sync"
"testing"
"github.com/klauspost/compress/zstd"
@@ -151,3 +153,34 @@ func TestCodexWarmGoesZstd(t *testing.T) {
t.Fatalf("warmed %q: %v", enc, got)
}
}
+
+// The encoder's coders and their histories live as long as the process, so
+// how many it keeps is set by magpie, not by the machine's cores: 28 turns
+// of 1 MiB at once on 16 cores held ~96 MB with the library's default of a
+// coder per core.
+func TestCodexZstdHoldsLittle(t *testing.T) {
+ defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(16))
+ var b bytes.Buffer
+ for i := 0; b.Len() < 1<<20; i++ {
+ b.WriteString(`{"role":"user","content":"line `)
+ b.WriteString(strings.Repeat("x", i*7919%61))
+ b.WriteString(`"},`)
+ }
+ src := b.Bytes()
+ var before, after runtime.MemStats
+ runtime.GC()
+ runtime.ReadMemStats(&before)
+ z := newCodexZstd()
+ var wg sync.WaitGroup
+ for range 28 {
+ wg.Add(1)
+ go func() { defer wg.Done(); z.EncodeAll(src, nil) }()
+ }
+ wg.Wait()
+ runtime.GC()
+ runtime.ReadMemStats(&after)
+ if held := int64(after.HeapInuse) - int64(before.HeapInuse); held > 24<<20 {
+ t.Fatalf("the encoder holds %d MB after 28 turns at once", held>>20)
+ }
+ runtime.KeepAlive(z)
+}