Files
CLIProxyAPI/internal/runtime/executor/helps/proxy_helpers.go
Luis Pater 2c5b01f439 fix(claude): disable default upstream connection reuse and revert post-stream draining
- Revert post-message_stop response body draining and detachable request context from Claude streaming execution so completed streams close immediately instead of returning connections to the idle pool.
- Set MaxIdleConnsPerHost to -1 on the default Claude Code uTLS transport to disable idle connection reuse for OAuth and unpooled credentials while preserving the Connection: keep-alive wire header and explicit connection-pool opt-in.
- Add regression tests verifying short-lived default Claude Code connections, explicit per-key pool reuse, and non-reused streaming connections.

Closes: #7357
2026-11-09 02:46:14 +08:00

612 lines
23 KiB
Go

package helps
import (
"context"
"crypto/sha256"
"encoding/hex"
"fmt"
"net"
"net/http"
"strings"
"sync"
"time"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
"github.com/router-for-me/CLIProxyAPI/v8/sdk/httptransport"
"github.com/router-for-me/CLIProxyAPI/v8/sdk/proxyutil"
log "github.com/sirupsen/logrus"
)
// NewProxyAwareHTTPClient creates an HTTP client with proper proxy configuration priority:
// 1. Use the execution-scoped request proxy if configured (highest priority)
// 2. Use auth.ProxyURL if configured
// 3. Use cfg.ProxyURL if auth proxy is not configured
// 4. Use RoundTripper from context if none are configured
//
// Parameters:
// - ctx: The context containing optional RoundTripper
// - cfg: The application configuration
// - auth: The authentication information
// - timeout: The client timeout (0 means no timeout)
//
// Returns:
// - *http.Client: An HTTP client with configured proxy or transport
func NewProxyAwareHTTPClient(ctx context.Context, cfg *config.Config, auth *cliproxyauth.Auth, timeout time.Duration) (clientOut *http.Client) {
defer func() { clientOut = httptransport.Decorate(ctx, clientOut) }()
httpClient := &http.Client{}
if timeout > 0 {
httpClient.Timeout = timeout
}
// Priority: request override, then auth.ProxyURL, then cfg.ProxyURL.
proxyURL := effectiveProxyURL(ctx, cfg, auth)
// Priority 1 & 2: Explicit proxy URL takes precedence over context RoundTripper.
if proxyURL != "" {
if transport := pooledProxyTransport(proxyURL, cfg, auth); transport != nil {
httpClient.Transport = transport
return httpClient
}
// If proxy setup failed, log and fall through to context RoundTripper
log.Debugf("failed to setup proxy from URL: %s, falling back to context transport", proxyutil.Redact(proxyURL))
}
// Priority 3: Use RoundTripper from context (typically from RoundTripperFor)
if ctx != nil {
if rt, ok := ctx.Value("cliproxy.roundtripper").(http.RoundTripper); ok && rt != nil {
httpClient.Transport = rt
return httpClient
}
}
// Priority 4: A credential may opt into pooling without an explicit proxy-url.
// With an empty proxy-url the pooled transport keeps the inherited
// environment-proxy behavior while isolating the credential's pool.
if transport := pooledProxyTransport("", cfg, auth); transport != nil {
httpClient.Transport = transport
}
return httpClient
}
// proxyPoolKey identifies one cached pool. publisher isolates the runtime that
// published the config, kind separates transports with different TLS fingerprints,
// scope isolates credentials, proxy is the normalized proxy setting, and the
// remaining fields fold in every setting that changes the built transport.
type proxyPoolKey struct {
publisher uint64
kind proxyPoolKind
scope string
proxy string
idle time.Duration
max int
invalidIdle string
}
// proxyPoolKind separates transports that cannot share a pool. The standard
// transport and the Claude Code uTLS transport differ in TLS fingerprint, HTTP
// version support, and header framing, so a transport built for one must never be
// handed to the other even when the proxy and pool settings match.
type proxyPoolKind uint8
const (
proxyPoolKindStandard proxyPoolKind = iota
proxyPoolKindClaudeCode
)
const (
// proxyPoolDefaultIdleConnTimeout bounds how long an idle pooled connection
// may survive before net/http closes it.
//
// Measured on 2026-10-29 against ollama.com through the local transparent
// proxy, which is the upstream this pool was introduced for: a pooled
// HTTP/2 connection was still reused after 120s, 180s, 300s and 600s of
// idleness, and a bare HTTP/1.1 connection survived an idle 600s without a
// close. 600s is therefore a lower bound on the upstream window, not a
// limit. The 90s that used to bound this path was net/http's own
// DefaultTransport IdleConnTimeout, a client-side timer rather than an
// upstream cutoff. 300s stays well inside the observed window while still
// recycling sockets, and it keeps the 31-300s request gaps that a 30s window
// throws away.
proxyPoolDefaultIdleConnTimeout = 300 * time.Second
// proxyPoolDefaultMaxIdleConnsPerHost mirrors net/http's
// DefaultMaxIdleConnsPerHost, so enabling the pool never retains more idle
// sockets per upstream host than the standard library default.
proxyPoolDefaultMaxIdleConnsPerHost = 2
// proxyPoolKeepAlivePeriod is the TCP keepalive interval stamped on every
// dialed upstream connection. Keepalive is what turns a silently dead peer
// (NAT timeout, killed proxy, dropped mobile link) into an error in tens of
// seconds instead of a request that blocks on TCP retransmits. It matches
// net/http's DefaultTransport dialer and only probes idle sockets, so it
// never truncates a long stream that is still flowing.
proxyPoolKeepAlivePeriod = 30 * time.Second
// proxyPoolCapacity bounds how many credential-scoped pools stay alive.
//
// The pool scales by eviction, not by sizing for the largest deployment:
// - 1 key: one entry, warm forever.
// - 100 keys: one entry each, nothing is evicted.
// - 100000 keys: the 512 most recently used credentials keep their pools
// and the rest fall back to the historical one-transport-per-request
// behavior, so memory stays at 512 transports and at most
// capacity*max idle sockets. Eviction only closes idle connections;
// in-flight requests keep their transport to completion.
proxyPoolCapacity = 512
)
var proxyTransportCache = NewTransportCache[proxyPoolKey](proxyPoolCapacity)
// proxyPoolFence tracks the current snapshot generation of every runtime that
// publishes configs. Fencing is per publisher: a reload in one service must never
// retire the snapshots another service is still serving, because retiring a live
// snapshot silently turns that service's pooling into a fresh transport per request.
// One small entry per runtime is retained for the process lifetime.
var proxyPoolFence struct {
sync.RWMutex
nextPublisher uint64
nextGeneration uint64
current map[uint64]uint64
}
// RegisterProxyPoolPublisher reserves one publisher identity per runtime. Pass the
// result to AdvanceProxyPoolGeneration on every publication.
func RegisterProxyPoolPublisher() uint64 {
proxyPoolFence.Lock()
defer proxyPoolFence.Unlock()
proxyPoolFence.nextPublisher++
return proxyPoolFence.nextPublisher
}
// AdvanceProxyPoolGeneration publishes cfg as the current snapshot of publisher and
// retires only that publisher's older snapshots. cfg must be a private snapshot not
// yet visible to request handlers. Pass 0 when the caller owns no publisher (direct
// SDK embedding, helper probes, tests); those snapshots fence each other.
func AdvanceProxyPoolGeneration(publisher uint64, cfg *config.Config) {
if cfg == nil {
return
}
proxyPoolFence.Lock()
proxyPoolFence.nextGeneration++
generation := proxyPoolFence.nextGeneration
if proxyPoolFence.current == nil {
proxyPoolFence.current = make(map[uint64]uint64)
}
proxyPoolFence.current[publisher] = generation
cfg.ProxyPoolPublisher = publisher
cfg.ProxyPoolGeneration = generation
// Retire this publisher's pools only, while the fence excludes its snapshots: a
// purged-then-refilled cache would resurrect transports built from retired
// settings. Purging the whole cache would close the idle connections of every
// other runtime on each reload of this one. Detach under the fence lock and
// close idle sockets after unlocking so socket teardown never blocks RLockers.
toClose := proxyTransportCache.detachMatching(func(key proxyPoolKey) bool { return key.publisher == publisher })
proxyPoolFence.Unlock()
for _, t := range toClose {
t.CloseIdleConnections()
}
}
// RetireProxyPoolPublisher closes all pooled transports owned by publisher and
// removes its fence state when the owning service shuts down. Any snapshot carrying
// a non-zero generation for this publisher will see current[publisher]==0 and remain
// fenced out of the shared cache.
func RetireProxyPoolPublisher(publisher uint64) {
if publisher == 0 {
return
}
proxyPoolFence.Lock()
delete(proxyPoolFence.current, publisher)
toClose := proxyTransportCache.detachMatching(func(key proxyPoolKey) bool { return key.publisher == publisher })
proxyPoolFence.Unlock()
for _, t := range toClose {
t.CloseIdleConnections()
}
}
// ResetProxyTransports closes idle connections in cached explicit proxy transports.
func ResetProxyTransports() { proxyTransportCache.Purge() }
func pooledProxyTransport(proxyURL string, cfg *config.Config, auth *cliproxyauth.Auth) *http.Transport {
tr, pooled := pooledTransport(proxyPoolKindStandard, proxyURL, cfg, auth, func() (*http.Transport, error) {
return buildPooledBaseTransport(proxyURL)
})
if pooled {
return tr
}
// Off unless this credential carries a connection-pool block. There is
// deliberately no global switch: pooling one api key must never change the
// transport lifecycle of another provider or OAuth identity. Without the
// block every request keeps the historical behavior of a fresh transport.
return buildProxyTransport(proxyURL)
}
// pooledTransport resolves one credential's pool for a transport kind. pooled is
// false when the credential did not opt in or its proxy setting cannot be pooled, so
// the caller keeps its historical transport.
func pooledTransport(kind proxyPoolKind, proxyURL string, cfg *config.Config, auth *cliproxyauth.Auth, build func() (*http.Transport, error)) (*http.Transport, bool) {
settings, enabled := resolveProxyPoolSettings(auth)
if !enabled {
return nil, false
}
setting, errParse := proxyutil.Parse(proxyURL)
if errParse != nil {
return nil, false
}
// When pooling against an empty proxy-url (net/http's inherited environment
// proxy), cloning http.DefaultTransport requires it to be a *http.Transport.
// If an SDK embedder installed a non-*http.Transport (e.g. mTLS, tracing, custom
// routing), decline pooling so the request keeps using the installed default
// instead of being replaced by an empty transport.
if kind == proxyPoolKindStandard && strings.TrimSpace(proxyURL) == "" {
if base, ok := http.DefaultTransport.(*http.Transport); !ok || base == nil {
return nil, false
}
}
idle := proxyPoolDefaultIdleConnTimeout
invalidIdle := ""
if raw := strings.TrimSpace(settings.IdleConnTimeout); raw != "" {
if d, err := time.ParseDuration(raw); err == nil {
if d <= 0 {
return unpooledTransport(build), true
}
idle = d
} else {
invalidIdle = raw
}
}
max := proxyPoolDefaultMaxIdleConnsPerHost
if settings.MaxIdleConnsPerHost != nil {
if *settings.MaxIdleConnsPerHost <= 0 {
return unpooledTransport(build), true
}
max = *settings.MaxIdleConnsPerHost
}
var publisher uint64
if cfg != nil {
publisher = cfg.ProxyPoolPublisher
}
cacheProxy, poolLabel := proxyPoolCacheTarget(setting)
key := proxyPoolKey{
publisher: publisher,
kind: kind,
scope: proxyPoolScope(auth),
proxy: cacheProxy,
idle: idle,
max: max,
invalidIdle: invalidIdle,
}
// Only a snapshot that carries a retired generation is fenced. Generation 0 means
// the config was never published through the SDK generation fence (direct api
// callers, helper probes, tests), so it cannot be stale and must still pool;
// treating it as stale would silently disable pooling for every non-SDK caller
// that builds its own config.Config. The read lock is held across the cache lookup
// so a concurrent publication cannot purge the cache and watch this snapshot refill
// it with a transport built from retired settings.
if cfg != nil && cfg.ProxyPoolGeneration != 0 {
proxyPoolFence.RLock()
defer proxyPoolFence.RUnlock()
if cfg.ProxyPoolGeneration != proxyPoolFence.current[cfg.ProxyPoolPublisher] {
return unpooledTransport(build), true
}
}
tr, err := proxyTransportCache.Get(key, func() (*http.Transport, error) {
tr, errBuild := build()
if errBuild != nil {
return nil, errBuild
}
if tr == nil {
return nil, fmt.Errorf("build returned no transport")
}
if invalidIdle != "" {
log.Warnf("proxy connection pool: invalid idle-conn-timeout %q, using %s", invalidIdle, proxyPoolDefaultIdleConnTimeout)
}
tr.IdleConnTimeout = idle
tr.MaxIdleConnsPerHost = max
// A cloned default transport keeps MaxIdleConns=100, which across 512
// credential pools would allow 51200 idle sockets. Bound the whole pool
// of one credential instead: at most max idle sockets in total.
tr.MaxIdleConns = max
if dial := tr.DialContext; dial != nil {
tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
conn, errDial := dial(ctx, network, addr)
if errDial != nil {
return nil, errDial
}
return stampProxyKeepAlive(conn), nil
}
}
log.Debugf("proxy connection pool: created transport kind=%d %s scope=%s idle=%s max=%d", kind, poolLabel, proxyPoolSecretScope("scope:", key.scope), idle, max)
return tr, nil
})
if err != nil {
log.Errorf("proxy connection pool: %v", err)
return nil, true
}
return tr, true
}
// resolveProxyPoolSettings resolves the pooling settings carried by one api-key
// credential. Writing the connection-pool block is the opt-in, so an omitted
// `enabled` means enabled and only an explicit `enabled: false` turns pooling off
// (a key opting out of its group). Omitted fields fall back to the pool defaults.
func resolveProxyPoolSettings(auth *cliproxyauth.Auth) (config.ProxyConnectionPoolConfig, bool) {
override := proxyPoolOverride(auth)
if override == nil {
return config.ProxyConnectionPoolConfig{}, false
}
if override.Enabled != nil && !*override.Enabled {
return config.ProxyConnectionPoolConfig{}, false
}
return config.ProxyConnectionPoolConfig{
Enabled: override.Enabled,
IdleConnTimeout: strings.TrimSpace(override.IdleConnTimeout),
MaxIdleConnsPerHost: override.MaxIdleConnsPerHost,
}, true
}
func proxyPoolOverride(auth *cliproxyauth.Auth) *cliproxyauth.ProxyConnectionPoolOverride {
if auth == nil {
return nil
}
return auth.ProxyConnectionPool
}
// proxyPoolCacheTarget returns the cache key and redacted log label for a parsed
// proxy setting. Authenticated proxies fold a short SHA-256 digest of user:pass
// into the cache key instead of raw credentials: each proxy identity (including
// sticky-session residential proxy usernames) keeps its own pool, rotating proxy
// credentials immediately switches pools, and plaintext secrets never sit in the
// cache key or logs.
func proxyPoolCacheTarget(setting proxyutil.Setting) (cacheProxy, poolLabel string) {
switch setting.Mode {
case proxyutil.ModeDirect:
// "direct" and "none" are the same setting and must not consume two slots.
return "direct", "direct"
case proxyutil.ModeInherit:
return "inherit", "inherit"
default:
redacted := proxyutil.Redact(setting.Raw)
if setting.URL != nil && setting.URL.User != nil {
return redacted + "#" + proxyPoolSecretScope("proxyauth:", setting.URL.User.String()), redacted
}
return setting.Raw, redacted
}
}
// proxyPoolAnonymousScope is the pool scope for requests that carry no credential.
const proxyPoolAnonymousScope = "anonymous"
// proxyPoolScope identifies the credential that owns a pool.
//
// Pooling must never mix accounts on one TCP/TLS connection: a shared connection
// correlates distinct identities upstream, and a rotated key would keep reusing a
// socket that was opened with the old one. Every credential therefore gets its own
// pool, mirroring the Antigravity executor's credential-scoped pools. The scope is
// only ever compared, never logged, so it cannot leak credential material.
func proxyPoolScope(auth *cliproxyauth.Auth) string {
if auth == nil {
return proxyPoolAnonymousScope
}
var identity string
if id := strings.TrimSpace(auth.ID); id != "" {
identity = "id:" + id
} else if auth.Attributes != nil {
if path := strings.TrimSpace(auth.Attributes[cliproxyauth.AttributePath]); path != "" {
identity = "path:" + path
} else if source := strings.TrimSpace(auth.Attributes[cliproxyauth.AttributeSource]); source != "" {
identity = "source:" + source
}
}
// Auth.Label is deliberately not used: it is an optional human readable label
// with no uniqueness guarantee, so two identities sharing a label would share a
// pool. Fold in digested credential material even when an ID/path/source is
// present so rotating an API key or token in-place under a stable Auth.ID
// switches pools instead of reusing a socket opened with the old secret.
secret := proxyPoolCredentialSecretScope(auth)
if identity != "" && secret != "" {
return identity + "#" + secret
}
if identity != "" {
return identity
}
if secret != "" {
return secret
}
return proxyPoolAnonymousScope
}
func proxyPoolCredentialSecretScope(auth *cliproxyauth.Auth) string {
if auth == nil {
return ""
}
if refresh := authMetadataString(auth.Metadata, "refresh_token"); refresh != "" {
return proxyPoolSecretScope("refresh:", refresh)
}
if access := authMetadataString(auth.Metadata, "access_token"); access != "" {
return proxyPoolSecretScope("token:", access)
}
if auth.Attributes != nil {
if apiKey := strings.TrimSpace(auth.Attributes[cliproxyauth.AttributeAPIKey]); apiKey != "" {
return proxyPoolSecretScope("apikey:", apiKey)
}
}
return ""
}
// proxyPoolSecretScope derives a scope from secret material. Only a short digest is
// retained, so a pool key cannot be turned back into the credential it came from.
func proxyPoolSecretScope(prefix, secret string) string {
digest := sha256.Sum256([]byte(secret))
return prefix + hex.EncodeToString(digest[:8])
}
func authMetadataString(metadata map[string]any, key string) string {
if metadata == nil {
return ""
}
value, ok := metadata[key]
if !ok {
return ""
}
text, _ := value.(string)
return strings.TrimSpace(text)
}
// unpooledTransport constructs a one-off transport for an opted-in credential that
// must bypass the shared cache (zero/negative pool bounds or a fenced config
// generation). It uses the kind's own builder so an unpooled uTLS transport keeps
// its TLS fingerprint. DisableKeepAlives is always set: no cache owns this transport,
// so any connection left in its idle list would survive until an idle timer fires.
func unpooledTransport(build func() (*http.Transport, error)) *http.Transport {
tr, errBuild := build()
if errBuild != nil {
log.Errorf("%v", errBuild)
return nil
}
if tr != nil {
tr.DisableKeepAlives = true
}
return tr
}
// buildPooledBaseTransport builds the transport a pool entry starts from. An empty
// proxy setting keeps net/http's inherited environment-proxy behavior and only takes
// ownership of the pool; explicit settings go through proxyutil as before.
func buildPooledBaseTransport(proxyURL string) (*http.Transport, error) {
if strings.TrimSpace(proxyURL) == "" {
if base, ok := http.DefaultTransport.(*http.Transport); ok && base != nil {
return base.Clone(), nil
}
return nil, fmt.Errorf("http.DefaultTransport is not *http.Transport")
}
tr, _, errBuild := proxyutil.BuildHTTPTransport(proxyURL)
if errBuild != nil {
return nil, errBuild
}
return tr, nil
}
// stampProxyKeepAlive enables TCP keepalive on a freshly dialed upstream
// connection. Direct and HTTP-proxy transports inherit net/http's keepalive dialer,
// but the SOCKS5 path dials through proxy.Direct, which leaves keepalive at the OS
// default of hours; a peer that died silently would then pin a pooled connection for
// that long. Keepalive only probes idle sockets, so a live stream is never cut.
func stampProxyKeepAlive(conn net.Conn) net.Conn {
tcp, ok := conn.(*net.TCPConn)
if !ok {
return conn
}
if err := tcp.SetKeepAlive(true); err != nil {
return conn
}
if err := tcp.SetKeepAlivePeriod(proxyPoolKeepAlivePeriod); err != nil {
return conn
}
return conn
}
var devinTransportCache = NewTransportCache[string](DefaultTransportCacheCapacity)
// NewDevinHTTPClient creates an HTTP client customized for Devin Connect-RPC upstream.
// Suppresses automatic Accept-Encoding: gzip while preserving connection reuse across requests.
func NewDevinHTTPClient(ctx context.Context, cfg *config.Config, auth *cliproxyauth.Auth, timeout time.Duration) (clientOut *http.Client) {
defer func() { clientOut = httptransport.Decorate(ctx, clientOut) }()
// A request proxy replaces both the injected round tripper and credential/global proxy.
// Respect explicitly injected context RoundTripper only when no request override is set.
if cliproxyexecutor.RequestProxyURL(ctx) == "" && ctx != nil {
if rt, ok := ctx.Value("cliproxy.roundtripper").(http.RoundTripper); ok && rt != nil {
if tr, ok := rt.(*http.Transport); ok {
key := fmt.Sprintf("rt:%p", tr)
cloned, err := devinTransportCache.Get(key, func() (*http.Transport, error) {
c := tr.Clone()
c.DisableCompression = true
return c, nil
})
if err == nil && cloned != nil {
return &http.Client{
Transport: cloned,
Timeout: timeout,
}
}
}
return &http.Client{
Transport: devinNoGzipRoundTripper{base: rt},
Timeout: timeout,
}
}
}
proxyURL := effectiveProxyURL(ctx, cfg, auth)
tr, err := devinTransportCache.Get(proxyURL, func() (*http.Transport, error) {
var base *http.Transport
if proxyURL != "" {
base = buildProxyTransport(proxyURL)
}
if base == nil {
if dt, ok := http.DefaultTransport.(*http.Transport); ok {
base = dt.Clone()
} else {
base = &http.Transport{}
}
}
base.DisableCompression = true
return base, nil
})
if err != nil || tr == nil {
tr = &http.Transport{DisableCompression: true}
}
return &http.Client{
Transport: tr,
Timeout: timeout,
}
}
type devinNoGzipRoundTripper struct {
base http.RoundTripper
}
func (rt devinNoGzipRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
if req.Header.Get("Accept-Encoding") == "" {
req.Header.Set("Accept-Encoding", "identity")
}
return rt.base.RoundTrip(req)
}
func effectiveProxyURL(ctx context.Context, cfg *config.Config, auth *cliproxyauth.Auth) string {
if proxyURL := cliproxyexecutor.RequestProxyURL(ctx); proxyURL != "" {
return proxyURL
}
if auth != nil {
if proxyURL := strings.TrimSpace(auth.ProxyURL); proxyURL != "" {
return proxyURL
}
}
if cfg != nil {
return strings.TrimSpace(cfg.ProxyURL)
}
return ""
}
// buildProxyTransport creates an HTTP transport configured for the given proxy URL.
// It supports SOCKS5, HTTP, and HTTPS proxy protocols.
//
// Parameters:
// - proxyURL: The proxy URL string (e.g., "socks5://user:pass@host:port", "http://host:port")
//
// Returns:
// - *http.Transport: A configured transport, or nil if the proxy URL is invalid
func buildProxyTransport(proxyURL string) *http.Transport {
transport, _, errBuild := proxyutil.BuildHTTPTransport(proxyURL)
if errBuild != nil {
log.Errorf("%v", errBuild)
return nil
}
return transport
}