fix(llm): give SimpleCall the same retry/backoff as the main loop

SimpleCall did a single http.Do with no retry, so any transient 429/5xx or
network blip aborted the best-effort secondary features that use it (skill
matching, memory summaries, episode extraction, session titles), while the
main agent Call retried. Extract the retry loop into postChatWithRetry and
route both through it.

Test: SimpleCall now succeeds after two 429s (3 attempts).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jkyberneees

internal/llm/client.go

@@ -209,30 +209,12 @@ func (c *Client) SimpleCall(ctx context.Context, systemPrompt, userPrompt string
 		return "", fmt.Errorf("llm: marshal request: %w", err)
 	}
 
-	url := c.BaseURL + "/chat/completions"
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(reqBytes))
-	if err != nil {
-		return "", fmt.Errorf("llm: create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+c.APIKey)
-
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("llm: %w", err)
-	}
-	defer resp.Body.Close()
-
-	respBytes, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseSize+1))
+	// Share the main loop's retry/backoff so a transient blip doesn't abort
+	// these best-effort secondary calls (skill matching, memory summaries,
+	// episode extraction, session titles).
+	respBytes, err := c.postChatWithRetry(ctx, reqBytes)
 	if err != nil {
-		return "", fmt.Errorf("llm: read response: %w", err)
-	}
-	if len(respBytes) > maxResponseSize {
-		return "", fmt.Errorf("llm: response exceeds maximum size (%d bytes)", maxResponseSize)
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("llm: %s (status %d)", resp.Status, resp.StatusCode)
+		return "", err
 	}
 
 	var raw struct {
@@ -300,14 +282,27 @@ func (c *Client) Call(ctx context.Context, messages []Message, systemBlocks []Sy
 		return nil, fmt.Errorf("llm: marshal request: %w", err)
 	}
 
+	respBytes, err := c.postChatWithRetry(ctx, reqBytes)
+	if err != nil {
+		return nil, err
+	}
+	return parseResponse(respBytes)
+}
+
+// postChatWithRetry POSTs reqBytes to /chat/completions and returns the raw 200
+// response body, retrying transient network errors and retryable HTTP statuses
+// (429, 502, 503, 504) with exponential backoff. Shared by every chat call so
+// the main loop and the lightweight secondary calls (SimpleCall) get identical
+// resilience. Respects ctx cancellation during the backoff sleep.
+func (c *Client) postChatWithRetry(ctx context.Context, reqBytes []byte) ([]byte, error) {
 	url := c.BaseURL + "/chat/completions"
 
 	const maxRetries = 3
 	var lastErr error
 
 	for attempt := 0; attempt <= maxRetries; attempt++ {
 		if attempt > 0 {
-			// Exponential backoff: 1s, 2s, 4s
+			// Exponential backoff: 1s, 2s, 4s.
 			backoff := time.Duration(1<<(attempt-1)) * time.Second
 			select {
 			case <-ctx.Done():
@@ -356,7 +351,7 @@ func (c *Client) Call(ctx context.Context, messages []Message, systemBlocks []Sy
 			return nil, lastErr
 		}
 
-		return parseResponse(respBytes)
+		return respBytes, nil
 	}
 
 	return nil, fmt.Errorf("llm: retry exhausted (%d attempts): %w", maxRetries+1, lastErr)

internal/llm/retry_test.go

@@ -9,6 +9,37 @@ import (
 	"time"
 )
 
+// TestClient_SimpleCall_RetryOn429 verifies the lightweight secondary calls
+// share the main loop's retry resilience: a transient 429 no longer aborts a
+// skill-match / memory / title call on the first failure.
+func TestClient_SimpleCall_RetryOn429(t *testing.T) {
+	var callCount atomic.Int32
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		count := int(callCount.Add(1))
+		if count <= 2 {
+			w.WriteHeader(http.StatusTooManyRequests)
+			w.Header().Set("Content-Type", "application/json")
+			w.Write([]byte(`{"error":{"message":"Rate limited"}}`))
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"choices":[{"message":{"content":"assessed"}}]}`))
+	}))
+	defer ts.Close()
+
+	c := New(ts.URL, "key", "model", "", 0, 10*time.Second)
+	out, err := c.SimpleCall(context.Background(), "sys", "user")
+	if err != nil {
+		t.Fatalf("unexpected error after retries: %v", err)
+	}
+	if out != "assessed" {
+		t.Errorf("content = %q, want %q", out, "assessed")
+	}
+	if callCount.Load() != 3 {
+		t.Errorf("call count = %d, want 3 (SimpleCall should retry)", callCount.Load())
+	}
+}
+
 func TestClient_Call_RetryOn429(t *testing.T) {
 	var callCount atomic.Int32
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {