Files
CLIProxyAPI/internal/runtime/executor/helps/response_decode.go
Luis Pater 064e008b07 feat(codex): add full-chain compression for Codex upstream and downstream traffic
- Compress finalized Codex OAuth request bodies with zstd on the verified ChatGPT backend path, with size/benefit gating, header-body alignment, and one uncompressed retry on 400/415 rejection.
- Negotiate downstream HTTP response compression under server.response-compression (zstd/gzip with q-values, SSE-safe flushing, commit-time Vary merging) and enable negotiated permessage-deflate on Codex and downstream WebSockets.
- Advertise Accept-Encoding to Codex upstreams and decode gzip/deflate/br/zstd upstream responses through a shared decoder before parsing or relaying.

Closes: #6905
2026-10-26 10:09:56 +08:00

182 lines
5.4 KiB
Go

package helps
import (
"bufio"
"compress/flate"
"compress/gzip"
"compress/zlib"
"fmt"
"io"
"net/http"
"strings"
"github.com/andybalholm/brotli"
"github.com/klauspost/compress/zstd"
log "github.com/sirupsen/logrus"
)
type compositeReadCloser struct {
io.Reader
closers []func() error
}
func (c *compositeReadCloser) Close() error {
var firstErr error
for i := range c.closers {
if c.closers[i] == nil {
continue
}
if errClose := c.closers[i](); errClose != nil && firstErr == nil {
firstErr = errClose
}
}
return firstErr
}
// peekableBody wraps a bufio.Reader around the original ReadCloser so that
// magic bytes can be inspected without consuming them from the stream.
type peekableBody struct {
*bufio.Reader
closer io.Closer
}
func (p *peekableBody) Close() error {
return p.closer.Close()
}
// DecodeResponseBody decodes declared encodings in reverse order, or sniffs gzip/zstd without a header.
// Closing the returned body also closes all decoders and the original body, including on setup errors.
func DecodeResponseBody(body io.ReadCloser, header http.Header) (io.ReadCloser, error) {
contentEncoding := strings.Join(header.Values("Content-Encoding"), ",")
if body == nil {
return nil, fmt.Errorf("response body is nil")
}
if contentEncoding == "" {
// No Content-Encoding header. Attempt best-effort magic-byte detection to
// handle misbehaving upstreams that compress without setting the header.
// Only gzip (1f 8b) and zstd (28 b5 2f fd) have reliable magic sequences;
// br and deflate have none and are left as-is.
// The bufio wrapper preserves unread bytes so callers always see the full
// stream regardless of whether decompression was applied.
pb := &peekableBody{Reader: bufio.NewReader(body), closer: body}
magic, peekErr := pb.Peek(4)
if peekErr == nil || (peekErr == io.EOF && len(magic) >= 2) {
switch {
case len(magic) >= 2 && magic[0] == 0x1f && magic[1] == 0x8b:
gzipReader, gzErr := gzip.NewReader(pb)
if gzErr != nil {
if errClose := pb.Close(); errClose != nil {
log.Errorf("response decoder: close body error: %v", errClose)
}
return nil, fmt.Errorf("magic-byte gzip: failed to create reader: %w", gzErr)
}
return &compositeReadCloser{
Reader: gzipReader,
closers: []func() error{
gzipReader.Close,
pb.Close,
},
}, nil
case len(magic) >= 4 && magic[0] == 0x28 && magic[1] == 0xb5 && magic[2] == 0x2f && magic[3] == 0xfd:
decoder, zdErr := zstd.NewReader(pb)
if zdErr != nil {
if errClose := pb.Close(); errClose != nil {
log.Errorf("response decoder: close body error: %v", errClose)
}
return nil, fmt.Errorf("magic-byte zstd: failed to create reader: %w", zdErr)
}
return &compositeReadCloser{
Reader: decoder,
closers: []func() error{
func() error { decoder.Close(); return nil },
pb.Close,
},
}, nil
}
}
return pb, nil
}
encodings := strings.Split(contentEncoding, ",")
reader := io.Reader(body)
decoderClosers := make([]func() error, 0, len(encodings))
cleanup := func() {
for i := len(decoderClosers) - 1; i >= 0; i-- {
if errClose := decoderClosers[i](); errClose != nil {
log.Errorf("response decoder: close decoder error: %v", errClose)
}
}
if errClose := body.Close(); errClose != nil {
log.Errorf("response decoder: close body error: %v", errClose)
}
}
for index := len(encodings) - 1; index >= 0; index-- {
encoding := strings.TrimSpace(strings.ToLower(encodings[index]))
switch encoding {
case "", "identity":
continue
case "gzip":
gzipReader, errGzip := gzip.NewReader(reader)
if errGzip != nil {
cleanup()
return nil, fmt.Errorf("failed to create gzip reader: %w", errGzip)
}
reader = gzipReader
decoderClosers = append(decoderClosers, gzipReader.Close)
case "deflate":
deflateReader, errDeflate := newResponseDeflateReader(reader)
if errDeflate != nil {
cleanup()
return nil, errDeflate
}
reader = deflateReader
decoderClosers = append(decoderClosers, deflateReader.Close)
case "br":
reader = brotli.NewReader(reader)
case "zstd":
decoder, errZstd := zstd.NewReader(reader)
if errZstd != nil {
cleanup()
return nil, fmt.Errorf("failed to create zstd reader: %w", errZstd)
}
reader = decoder
decoderClosers = append(decoderClosers, func() error {
decoder.Close()
return nil
})
default:
cleanup()
return nil, fmt.Errorf("unsupported content encoding %q", encoding)
}
}
if len(decoderClosers) == 0 && reader == body {
return body, nil
}
closers := make([]func() error, 0, len(decoderClosers)+1)
for index := len(decoderClosers) - 1; index >= 0; index-- {
closers = append(closers, decoderClosers[index])
}
closers = append(closers, body.Close)
return &compositeReadCloser{Reader: reader, closers: closers}, nil
}
func newResponseDeflateReader(reader io.Reader) (io.ReadCloser, error) {
buffered := bufio.NewReader(reader)
header, errPeek := buffered.Peek(2)
if errPeek == nil && isZlibHeader(header) {
zlibReader, errZlib := zlib.NewReader(buffered)
if errZlib != nil {
return nil, fmt.Errorf("failed to create zlib deflate reader: %w", errZlib)
}
return zlibReader, nil
}
return flate.NewReader(buffered), nil
}
func isZlibHeader(header []byte) bool {
if len(header) < 2 {
return false
}
cmf, flg := header[0], header[1]
return cmf&0x0f == 8 && cmf>>4 <= 7 && (uint16(cmf)<<8|uint16(flg))%31 == 0
}