Anthropic Messages adapter (#40)

Co-authored-by: dev_agent <dev_agent@cubecraftlabs.com>
Co-committed-by: dev_agent <dev_agent@cubecraftlabs.com>

internal/ai/llm/openai/openai.go

@@ -15,6 +15,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"net"
 	"net/http"
 	"net/textproto"
@@ -132,7 +133,7 @@ func newFromConfig(cfg Config) (*Provider, error) {
 		model:   cfg.Model,
 		headers: headers,
 		mode:    cfg.StructuredOutput,
-		client:  &http.Client{},
+		client:  noRedirectClient(),
 	}, nil
 }
 
@@ -462,10 +463,15 @@ func retryAfter(value string, now time.Time) time.Duration {
 	if value == "" {
 		return 0
 	}
-	if secs, err := strconv.Atoi(value); err == nil {
+	if secs, err := strconv.ParseInt(value, 10, 64); err == nil || errors.Is(err, strconv.ErrRange) {
 		if secs < 0 {
 			return 0
 		}
+		// time.Duration counts nanoseconds in an int64; a larger wait is
+		// capped to the most whole seconds it holds instead of overflowing.
+		if secs > maxRetryAfterSeconds {
+			secs = maxRetryAfterSeconds
+		}
 		return time.Duration(secs) * time.Second
 	}
 	if at, err := http.ParseTime(value); err == nil && at.After(now) {
@@ -474,6 +480,22 @@ func retryAfter(value string, now time.Time) time.Duration {
 	return 0
 }
 
+// maxRetryAfterSeconds is the largest delay-seconds value retryAfter
+// returns unchanged: the most whole seconds a time.Duration holds.
+const maxRetryAfterSeconds = math.MaxInt64 / int64(time.Second)
+
+// noRedirectClient returns an HTTP client that never follows a redirect.
+// A followed redirect would resend the credential headers, which net/http
+// strips only for its own list of sensitive headers and only across hosts;
+// instead the 3xx response is returned and becomes a provider error.
+func noRedirectClient() *http.Client {
+	return &http.Client{
+		CheckRedirect: func(*http.Request, []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+}
+
 func isTimeout(err error) bool {
 	var ne net.Error
 	return errors.Is(err, context.DeadlineExceeded) || (errors.As(err, &ne) && ne.Timeout())
@@ -483,16 +505,14 @@ func isTimeout(err error) bool {
 // with the request URL removed and the API key redacted, and unwraps only to
 // the cause's category: llm.ErrTimeout, context.Canceled or nothing.
 type transportFailure struct {
-	detail string
-	kind   error
+	text string
+	kind error
 }
 
-func (e *transportFailure) Error() string {
-	if e.kind == llm.ErrTimeout {
-		return fmt.Sprintf("%s: transport: %s", llm.ErrTimeout, e.detail)
-	}
-	return "transport: " + e.detail
-}
+func (e *transportFailure) Error() string { return e.text }
+
+// GoString keeps %#v to the redacted Error text instead of the fields.
+func (e *transportFailure) GoString() string { return e.text }
 
 func (e *transportFailure) Unwrap() error { return e.kind }
 
@@ -511,7 +531,11 @@ func (p *Provider) transportError(err error) error {
 	if errors.As(err, &ue) {
 		err = ue.Err
 	}
-	return &transportFailure{detail: llm.Redact(err.Error(), p.apiKey), kind: kind}
+	text := "transport: " + err.Error()
+	if kind == llm.ErrTimeout {
+		text = fmt.Sprintf("%s: %s", llm.ErrTimeout, text)
+	}
+	return &transportFailure{text: llm.Redact(text, p.apiKey), kind: kind}
 }
 
 // redactedError stands in for one layer of an error chain that holds the
@@ -520,8 +544,8 @@ func (p *Provider) transportError(err error) error {
 // unwrapping has text holding the key. Is consults the original layer and
 // its chain, so sentinels still match. As does too. The llm typed errors
 // remove the key from their own complete text, fixed words included, so
-// they always match; As refuses only a match from outside llm whose text
-// holds the key, so it never hands back an unredacted error.
+// they always match; As refuses a match whose text, or whose %#v form,
+// holds the key, so it never hands back an error that can print it.
 type redactedError struct {
 	text string
 	err  error
@@ -530,6 +554,9 @@ type redactedError struct {
 
 func (e *redactedError) Error() string { return e.text }
 
+// GoString keeps %#v from printing the fields, which hold the key.
+func (e *redactedError) GoString() string { return e.text }
+
 func (e *redactedError) Unwrap() error { return redact(errors.Unwrap(e.err), e.key) }
 
 func (e *redactedError) Is(target error) bool { return errors.Is(e.err, target) }
@@ -539,7 +566,8 @@ func (e *redactedError) As(target any) bool {
 		return false
 	}
 	found := reflect.ValueOf(target).Elem()
-	if matched, ok := found.Interface().(error); ok && holdsKey(matched, e.key) {
+	matched, isErr := found.Interface().(error)
+	if (isErr && holdsKey(matched, e.key)) || strings.Contains(fmt.Sprintf("%#v", found.Interface()), e.key) {
 		found.SetZero()
 		return false
 	}
@@ -561,12 +589,13 @@ func (e *redactedJoin) Unwrap() []error {
 	return safe
 }
 
-// redact is the backstop every exported method applies to its error: when
-// the text of err or of any error in its chain holds a non-empty key, it
-// returns a stand-in whose text, and the text of every error it unwraps
-// to, has the key redacted. Any other err is returned unchanged.
+// redact is the backstop every exported method applies to its error: with
+// a non-empty key, it returns a stand-in whose text, and the text of every
+// error it unwraps to, has the key redacted. Every non-nil err is wrapped,
+// even one whose text lacks the key, because %#v of an unwrapped error
+// prints its struct field names, and a key may spell one.
 func redact(err error, key string) error {
-	if err == nil || key == "" || !holdsKey(err, key) {
+	if err == nil || key == "" {
 		return err
 	}
 	re := redactedError{text: llm.Redact(err.Error(), key), err: err, key: key}