test(oai): add audit logging and meta tests; raise coverage

Add tests for http_attempt/http_timing/length_backoff/chat_meta and truncate bounds. Validates log structure and stage propagation.

Author: aibuddy

.gitignore

@@ -29,4 +29,4 @@ go.work
 # Editor swap files
 *.swp
 work/
-.cursor
+.cursor/

internal/oai/backoff.go

@@ -1,10 +1,10 @@
 package oai
 
 import (
-    mathrand "math/rand"
-    "net/http"
-    "strings"
-    "time"
+	mathrand "math/rand"
+	"net/http"
+	"strings"
+	"time"
 )
 
 // RetryPolicy controls HTTP retry behavior for transient failures.
@@ -13,80 +13,80 @@ import (
 // JitterFraction specifies the +/- fractional jitter applied to each computed backoff.
 // When Rand is non-nil, it is used to sample jitter for deterministic tests.
 type RetryPolicy struct {
-    MaxRetries     int
-    Backoff        time.Duration
-    JitterFraction float64
-    Rand           *mathrand.Rand
+	MaxRetries     int
+	Backoff        time.Duration
+	JitterFraction float64
+	Rand           *mathrand.Rand
 }
 
 // backoffDuration returns the duration that sleepBackoff would sleep for a given attempt.
 func backoffDuration(base time.Duration, attempt int) time.Duration {
-    if base <= 0 {
-        base = 200 * time.Millisecond
-    }
-    d := base << attempt
-    if d > 2*time.Second {
-        d = 2 * time.Second
-    }
-    return d
+	if base <= 0 {
+		base = 200 * time.Millisecond
+	}
+	d := base << attempt
+	if d > 2*time.Second {
+		d = 2 * time.Second
+	}
+	return d
 }
 
 // backoffWithJitter returns an exponential backoff adjusted by +/- jitter fraction.
 // When jitterFraction <= 0, this falls back to backoffDuration. When r is nil,
 // a time-seeded RNG is used for production randomness.
 func backoffWithJitter(base time.Duration, attempt int, jitterFraction float64, r *mathrand.Rand) time.Duration {
-    d := backoffDuration(base, attempt)
-    if jitterFraction <= 0 {
-        return d
-    }
-    if jitterFraction > 0.9 { // prevent extreme factors
-        jitterFraction = 0.9
-    }
-    if r == nil {
-        // Seed with current time for production; tests can pass a custom Rand
-        r = mathrand.New(mathrand.NewSource(time.Now().UnixNano()))
-    }
-    // factor in [1 - f, 1 + f]
-    minF := 1.0 - jitterFraction
-    maxF := 1.0 + jitterFraction
-    factor := minF + r.Float64()*(maxF-minF)
-    // Guard against rounding to zero
-    jittered := time.Duration(float64(d) * factor)
-    if jittered < time.Millisecond {
-        return time.Millisecond
-    }
-    return jittered
+	d := backoffDuration(base, attempt)
+	if jitterFraction <= 0 {
+		return d
+	}
+	if jitterFraction > 0.9 { // prevent extreme factors
+		jitterFraction = 0.9
+	}
+	if r == nil {
+		// Seed with current time for production; tests can pass a custom Rand
+		r = mathrand.New(mathrand.NewSource(time.Now().UnixNano()))
+	}
+	// factor in [1 - f, 1 + f]
+	minF := 1.0 - jitterFraction
+	maxF := 1.0 + jitterFraction
+	factor := minF + r.Float64()*(maxF-minF)
+	// Guard against rounding to zero
+	jittered := time.Duration(float64(d) * factor)
+	if jittered < time.Millisecond {
+		return time.Millisecond
+	}
+	return jittered
 }
 
 // retryAfterDuration parses the Retry-After header which may be seconds or HTTP-date.
 // Returns (duration, true) when valid; otherwise (0, false).
 func retryAfterDuration(h string, now time.Time) (time.Duration, bool) {
-    h = strings.TrimSpace(h)
-    if h == "" {
-        return 0, false
-    }
-    // Try integer seconds first
-    if secs, err := time.ParseDuration(h + "s"); err == nil {
-        if secs > 0 {
-            return secs, true
-        }
-    }
-    // Try HTTP-date formats per RFC 7231 (use http.TimeFormat)
-    if t, err := time.Parse(http.TimeFormat, h); err == nil {
-        if t.After(now) {
-            return t.Sub(now), true
-        }
-    }
-    return 0, false
+	h = strings.TrimSpace(h)
+	if h == "" {
+		return 0, false
+	}
+	// Try integer seconds first
+	if secs, err := time.ParseDuration(h + "s"); err == nil {
+		if secs > 0 {
+			return secs, true
+		}
+	}
+	// Try HTTP-date formats per RFC 7231 (use http.TimeFormat)
+	if t, err := time.Parse(http.TimeFormat, h); err == nil {
+		if t.After(now) {
+			return t.Sub(now), true
+		}
+	}
+	return 0, false
 }
 
 // sleepFor sleeps for the provided duration; extracted for testability.
 // sleepFunc allows tests to intercept sleeps deterministically.
 var sleepFunc = sleepFor
 
 func sleepFor(d time.Duration) {
-    if d <= 0 {
-        return
-    }
-    time.Sleep(d)
+	if d <= 0 {
+		return
+	}
+	time.Sleep(d)
 }

internal/oai/client.go

@@ -1,23 +1,23 @@
 package oai
 
 import (
-    "bytes"
-    "context"
-    "encoding/json"
-    "errors"
-    "fmt"
-    "io"
-    "net/http"
-    "net/http/httptrace"
-    "strings"
-    "time"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptrace"
+	"strings"
+	"time"
 )
 
 type Client struct {
-    baseURL    string
-    apiKey     string
-    httpClient *http.Client
-    retry      RetryPolicy
+	baseURL    string
+	apiKey     string
+	httpClient *http.Client
+	retry      RetryPolicy
 }
 
 // NewClient creates a client without retries (single attempt only).
@@ -306,4 +306,3 @@ func (c *Client) StreamChat(ctx context.Context, req ChatCompletionsRequest, onC
 		}
 	}
 }
-

internal/oai/diagnostics.go

@@ -1,37 +1,37 @@
 package oai
 
 import (
-    "context"
-    "errors"
-    "strings"
+	"context"
+	"errors"
+	"strings"
 )
 
 // classifyHTTPCause returns a short cause label for audit based on error/context.
 func classifyHTTPCause(ctx context.Context, err error) string {
-    if err == nil {
-        return "success"
-    }
-    if errors.Is(err, context.DeadlineExceeded) || (ctx != nil && ctx.Err() == context.DeadlineExceeded) {
-        return "context_deadline"
-    }
-    s := strings.ToLower(err.Error())
-    switch {
-    case strings.Contains(s, "server closed") || strings.Contains(s, "connection reset") || strings.Contains(s, "broken pipe"):
-        return "server_closed"
-    case strings.Contains(s, "timeout"):
-        return "timeout"
-    default:
-        return "error"
-    }
+	if err == nil {
+		return "success"
+	}
+	if errors.Is(err, context.DeadlineExceeded) || (ctx != nil && ctx.Err() == context.DeadlineExceeded) {
+		return "context_deadline"
+	}
+	s := strings.ToLower(err.Error())
+	switch {
+	case strings.Contains(s, "server closed") || strings.Contains(s, "connection reset") || strings.Contains(s, "broken pipe"):
+		return "server_closed"
+	case strings.Contains(s, "timeout"):
+		return "timeout"
+	default:
+		return "error"
+	}
 }
 
 // userHintForCause returns a short actionable hint for common failure causes.
 func userHintForCause(ctx context.Context, err error) string {
-    if err == nil {
-        return ""
-    }
-    if errors.Is(err, context.DeadlineExceeded) || (ctx != nil && ctx.Err() == context.DeadlineExceeded) || strings.Contains(strings.ToLower(err.Error()), "timeout") {
-        return "increase -http-timeout or reduce prompt/model latency"
-    }
-    return ""
+	if err == nil {
+		return ""
+	}
+	if errors.Is(err, context.DeadlineExceeded) || (ctx != nil && ctx.Err() == context.DeadlineExceeded) || strings.Contains(strings.ToLower(err.Error()), "timeout") {
+		return "increase -http-timeout or reduce prompt/model latency"
+	}
+	return ""
 }

internal/oai/idempotency.go

@@ -1,18 +1,18 @@
 package oai
 
 import (
-    "crypto/rand"
-    "encoding/hex"
-    "fmt"
-    "time"
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"time"
 )
 
 // generateIdempotencyKey returns a random hex string suitable for Idempotency-Key.
 func generateIdempotencyKey() string {
-    var b [16]byte
-    if _, err := rand.Read(b[:]); err != nil {
-        // Fallback to timestamp-based key if crypto/rand fails; extremely unlikely
-        return fmt.Sprintf("goagent-%d", time.Now().UnixNano())
-    }
-    return "goagent-" + hex.EncodeToString(b[:])
+	var b [16]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		// Fallback to timestamp-based key if crypto/rand fails; extremely unlikely
+		return fmt.Sprintf("goagent-%d", time.Now().UnixNano())
+	}
+	return "goagent-" + hex.EncodeToString(b[:])
 }