From 15484ac06cad5a17ac8fa3451ac12f5442262f09 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 11:54:58 +0000 Subject: [PATCH] Resend provider requests that were never written POST /send returned 500 "provider transport failure" after 157ms: the Twitch request failed at the connection, before any response. Go's transport only replays such failures on reused connections, and never replays a POST otherwise, so a connection that failed during setup surfaced as an error although Twitch never saw the message. clients.Do now traces each request. When the transport began getting a connection and wrote nothing (no headers, no request), the request had no effect, so it is resent once whatever its method. A request that may have been written stays an error, so a chat message is never posted twice, and a transport that reports neither is treated as ambiguous. (Twitch keeps idle connections for 240s, longer than Go's 90s idle timeout, so a server-closed idle connection isn't the cause.) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01EzdqAWrbTMdtJutmK41coy --- agent/internal/clients/client.go | 46 +++++++++++++------- agent/internal/clients/unsent_test.go | 60 +++++++++++++++++++++++++++ 2 files changed, 91 insertions(+), 15 deletions(-) create mode 100644 agent/internal/clients/unsent_test.go diff --git a/agent/internal/clients/client.go b/agent/internal/clients/client.go index cbb45aa11..215018cbb 100644 --- a/agent/internal/clients/client.go +++ b/agent/internal/clients/client.go @@ -9,6 +9,7 @@ import ( "fmt" "io" "net/http" + "net/http/httptrace" "strings" "time" ) @@ -73,28 +74,43 @@ func (c Client) Do(ctx context.Context, method, path string, body any) (*Respons return nil, err } } - req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(c.BaseURL, "/")+path, bytes.NewReader(encoded)) - if err != nil { - return nil, errors.New("invalid provider request") - } - req.Header = c.Headers.Clone() - if req.Header == nil { - req.Header = make(http.Header) - } - req.Header.Set("Accept", "application/json") - if body != nil { - req.Header.Set("Content-Type", "application/json") - } client := c.HTTP if client == nil { client = &http.Client{Timeout: 10 * time.Second} } - response, err := client.Do(req) - if err != nil { + var response *http.Response + // A request the transport began sending but never wrote, e.g. because the + // connection failed during setup, had no effect, so it is resent once + // whatever its method. A transport that reports neither is ambiguous. + for attempt := 0; ; attempt++ { + connecting, written := false, false + trace := &httptrace.ClientTrace{ + GetConn: func(string) { connecting = true }, + WroteHeaders: func() { written = true }, + WroteRequest: func(httptrace.WroteRequestInfo) { written = true }, + } + req, err := http.NewRequestWithContext(httptrace.WithClientTrace(ctx, trace), method, strings.TrimRight(c.BaseURL, "/")+path, bytes.NewReader(encoded)) + if err != nil { + return nil, errors.New("invalid provider request") + } + req.Header = c.Headers.Clone() + if req.Header == nil { + req.Header = make(http.Header) + } + req.Header.Set("Accept", "application/json") + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + response, err = client.Do(req) + if err == nil { + break + } if ctx.Err() != nil { return nil, ctx.Err() } - return nil, errors.New("provider transport failure") + if !connecting || written || attempt == 1 { + return nil, errors.New("provider transport failure") + } } defer response.Body.Close() data, err := io.ReadAll(io.LimitReader(response.Body, (8<<20)+1)) diff --git a/agent/internal/clients/unsent_test.go b/agent/internal/clients/unsent_test.go new file mode 100644 index 000000000..f6905060a --- /dev/null +++ b/agent/internal/clients/unsent_test.go @@ -0,0 +1,60 @@ +package clients + +import ( + "context" + "io" + "net" + "net/http" + "net/http/httptest" + "sync/atomic" + "testing" +) + +// dropFirst closes the first connection it accepts before the TLS handshake +// finishes, as a reset during connection setup does. +type dropFirst struct { + net.Listener + accepted atomic.Int32 +} + +func (l *dropFirst) Accept() (net.Conn, error) { + for { + conn, err := l.Listener.Accept() + if err != nil || l.accepted.Add(1) > 1 { + return conn, err + } + conn.Close() + } +} + +// A request that never reached the provider has no effect, so even a chat +// POST is safe to send again; one the provider may have received is not. +func TestDoResendsRequestsThatWereNeverWritten(t *testing.T) { + var received atomic.Int32 + server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + received.Add(1) + io.WriteString(w, `{}`) + })) + server.Listener = &dropFirst{Listener: server.Listener} + server.StartTLS() + defer server.Close() + client := Client{HTTP: server.Client(), BaseURL: server.URL} + response, err := client.Do(context.Background(), http.MethodPost, "/chat/messages", map[string]string{"message": "hi"}) + if err != nil || response.StatusCode != 200 || received.Load() != 1 { + t.Fatalf("err=%v received=%d", err, received.Load()) + } +} + +func TestDoDoesNotResendWrittenRequests(t *testing.T) { + var received atomic.Int32 + server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + received.Add(1) + conn, _, _ := w.(http.Hijacker).Hijack() + conn.Close() // received, but no response: the outcome is unknown + })) + defer server.Close() + client := Client{HTTP: server.Client(), BaseURL: server.URL} + if _, err := client.Do(context.Background(), http.MethodPost, "/chat/messages", map[string]string{"message": "hi"}); err == nil || received.Load() != 1 { + t.Fatalf("err=%v received=%d; an ambiguous POST was resent", err, received.Load()) + } +}