fix: LLM provider with exponential backoff, streaming, token tracking

backend/app/services/llm_provider.py

@@ -1,44 +1,101 @@
 """
-TestGenius AI — Universal LLM Provider (Custom Base URL + Model)
-=================================================================
-Users configure in .env:
-  LLM_BASE_URL=https://api.featherless.ai/v1
-  LLM_API_KEY=your-key
-  LLM_MODEL=meta-llama/Meta-Llama-3.1-70B-Instruct
-
-Works with ANY OpenAI-compatible API: OpenAI, Featherless, Groq, Together,
-DeepSeek, OpenRouter, Mistral, Ollama, LM Studio, vLLM, etc.
+TestGenius AI — Universal LLM Provider (v2 — ALL FIXES)
+=========================================================
+FIXES:
+1. ✅ Exponential backoff retry (not just single 429 retry)
+2. ✅ Streaming support for long generations
+3. ✅ Token usage tracking per request
+4. ✅ Request/response logging for debugging
+5. ✅ Configurable timeout per-call
 """
 
 import os
+import time
 import logging
+import asyncio
 import httpx
-from typing import Optional, Dict
+from typing import Optional, Dict, Any
+from dataclasses import dataclass, field
 
 logger = logging.getLogger(__name__)
 
-# ═══ CONFIGURATION FROM .env ═══
+# ═══ CONFIGURATION ═══
 
 LLM_BASE_URL = os.environ.get("LLM_BASE_URL", "https://api.groq.com/openai/v1")
 LLM_API_KEY = os.environ.get("LLM_API_KEY", "")
 LLM_MODEL = os.environ.get("LLM_MODEL", "llama-3.3-70b-versatile")
 LLM_MAX_TOKENS = int(os.environ.get("LLM_MAX_TOKENS", "8192"))
 LLM_TEMPERATURE = float(os.environ.get("LLM_TEMPERATURE", "0.3"))
+LLM_TIMEOUT = float(os.environ.get("LLM_TIMEOUT", "120"))
 
 
+# ═══ TOKEN TRACKING ═══
+
+@dataclass
+class UsageStats:
+    """Track token usage across the session."""
+    total_prompt_tokens: int = 0
+    total_completion_tokens: int = 0
+    total_requests: int = 0
+    total_errors: int = 0
+    total_retries: int = 0
+    total_latency_ms: float = 0
+    requests: list = field(default_factory=list)
+
+    @property
+    def total_tokens(self) -> int:
+        return self.total_prompt_tokens + self.total_completion_tokens
+
+    @property
+    def avg_latency_ms(self) -> float:
+        return self.total_latency_ms / max(self.total_requests, 1)
+
+    def to_dict(self) -> Dict:
+        return {
+            "total_prompt_tokens": self.total_prompt_tokens,
+            "total_completion_tokens": self.total_completion_tokens,
+            "total_tokens": self.total_tokens,
+            "total_requests": self.total_requests,
+            "total_errors": self.total_errors,
+            "total_retries": self.total_retries,
+            "avg_latency_ms": round(self.avg_latency_ms, 1),
+            "estimated_cost_usd": self._estimate_cost(),
+        }
+
+    def _estimate_cost(self) -> float:
+        # Rough estimate based on common pricing
+        prompt_cost = self.total_prompt_tokens * 0.0000003  # ~$0.30/1M tokens
+        completion_cost = self.total_completion_tokens * 0.0000006  # ~$0.60/1M tokens
+        return round(prompt_cost + completion_cost, 4)
+
+
+# Global usage tracker
+_usage = UsageStats()
+
+
+def get_usage_stats() -> Dict:
+    """Get current token usage statistics."""
+    return _usage.to_dict()
+
+
+def reset_usage_stats():
+    """Reset usage tracking."""
+    global _usage
+    _usage = UsageStats()
+
+
+# ═══ MAIN LLM INTERFACE ═══
+
 async def generate_with_llm(
     prompt: str,
     system_prompt: str,
     temperature: Optional[float] = None,
     max_tokens: Optional[int] = None,
+    timeout: Optional[float] = None,
 ) -> str:
     """
     Generate text using ANY OpenAI-compatible LLM provider.
-    
-    Configure via environment variables:
-      LLM_BASE_URL  — API endpoint (e.g., https://api.featherless.ai/v1)
-      LLM_API_KEY   — API key
-      LLM_MODEL     — Model name (e.g., meta-llama/Meta-Llama-3.1-70B-Instruct)
+    FIX: Exponential backoff, token tracking, better error handling.
     """
     if not LLM_API_KEY:
         raise RuntimeError(
@@ -49,13 +106,12 @@ async def generate_with_llm(
         )
 
     url = f"{LLM_BASE_URL.rstrip('/')}/chat/completions"
-    
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {LLM_API_KEY}",
     }
-    
-    # Some providers need extra headers
+
+    # Provider-specific headers
     if "openrouter" in LLM_BASE_URL:
         headers["HTTP-Referer"] = "https://testgenius-ai.app"
         headers["X-Title"] = "TestGenius AI"
@@ -70,42 +126,150 @@ async def generate_with_llm(
         "max_tokens": max_tokens or LLM_MAX_TOKENS,
     }
 
-    try:
-        async with httpx.AsyncClient(timeout=120.0) as client:
-            response = await client.post(url, headers=headers, json=payload)
+    request_timeout = timeout or LLM_TIMEOUT
+    start_time = time.time()
 
-            if response.status_code == 429:
-                logger.warning("Rate limited — retrying after 2s")
-                import asyncio
-                await asyncio.sleep(2)
+    # Exponential backoff retry
+    max_retries = 3
+    for attempt in range(max_retries + 1):
+        try:
+            async with httpx.AsyncClient(timeout=request_timeout) as client:
                 response = await client.post(url, headers=headers, json=payload)
 
+                if response.status_code == 429:
+                    # Rate limited — exponential backoff
+                    _usage.total_retries += 1
+                    if attempt < max_retries:
+                        wait_time = (2 ** attempt) + 1  # 2s, 5s, 9s
+                        retry_after = response.headers.get("Retry-After")
+                        if retry_after:
+                            try:
+                                wait_time = min(int(retry_after), 30)
+                            except ValueError:
+                                pass
+                        logger.warning(f"Rate limited (429). Retry {attempt+1}/{max_retries} after {wait_time}s")
+                        await asyncio.sleep(wait_time)
+                        continue
+                    else:
+                        _usage.total_errors += 1
+                        raise RuntimeError(f"Rate limited after {max_retries} retries. Try again later.")
+
+                if response.status_code == 503:
+                    # Service unavailable — retry
+                    _usage.total_retries += 1
+                    if attempt < max_retries:
+                        wait_time = (2 ** attempt) + 1
+                        logger.warning(f"Service unavailable (503). Retry {attempt+1}/{max_retries}")
+                        await asyncio.sleep(wait_time)
+                        continue
+
+                if response.status_code != 200:
+                    _usage.total_errors += 1
+                    error_text = response.text[:300]
+                    logger.error(f"LLM Error [{LLM_BASE_URL}] {response.status_code}: {error_text}")
+                    raise RuntimeError(f"LLM API error {response.status_code}: {error_text}")
+
+                data = response.json()
+                content = data["choices"][0]["message"]["content"]
+
+                # Track token usage
+                usage = data.get("usage", {})
+                latency = (time.time() - start_time) * 1000
+
+                _usage.total_prompt_tokens += usage.get("prompt_tokens", 0)
+                _usage.total_completion_tokens += usage.get("completion_tokens", 0)
+                _usage.total_requests += 1
+                _usage.total_latency_ms += latency
+
+                logger.info(
+                    f"LLM: {len(content)} chars, "
+                    f"{usage.get('total_tokens', '?')} tokens, "
+                    f"{latency:.0f}ms — {LLM_MODEL} via {_detect_provider()}"
+                )
+
+                return content
+
+        except httpx.TimeoutException:
+            _usage.total_retries += 1
+            if attempt < max_retries:
+                logger.warning(f"Timeout after {request_timeout}s. Retry {attempt+1}/{max_retries}")
+                await asyncio.sleep(2 ** attempt)
+                continue
+            _usage.total_errors += 1
+            raise RuntimeError(f"LLM request timed out after {max_retries} retries ({request_timeout}s each)")
+
+        except httpx.ConnectError:
+            _usage.total_errors += 1
+            raise RuntimeError(f"Cannot connect to LLM at {LLM_BASE_URL}")
+
+    _usage.total_errors += 1
+    raise RuntimeError("LLM request failed after all retries")
+
+
+async def generate_with_llm_streaming(
+    prompt: str,
+    system_prompt: str,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None,
+):
+    """
+    FIX: Streaming generation for long outputs. Yields chunks as they arrive.
+    Use when generating large test suites to reduce perceived latency.
+    """
+    if not LLM_API_KEY:
+        raise RuntimeError("LLM_API_KEY not set")
+
+    url = f"{LLM_BASE_URL.rstrip('/')}/chat/completions"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {LLM_API_KEY}",
+    }
+
+    payload = {
+        "model": LLM_MODEL,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": prompt},
+        ],
+        "temperature": temperature or LLM_TEMPERATURE,
+        "max_tokens": max_tokens or LLM_MAX_TOKENS,
+        "stream": True,
+    }
+
+    async with httpx.AsyncClient(timeout=LLM_TIMEOUT) as client:
+        async with client.stream("POST", url, headers=headers, json=payload) as response:
             if response.status_code != 200:
-                error_text = response.text[:300]
-                logger.error(f"LLM Error [{LLM_BASE_URL}] {response.status_code}: {error_text}")
-                raise RuntimeError(f"LLM API error {response.status_code}: {error_text}")
+                raise RuntimeError(f"LLM streaming error: {response.status_code}")
 
-            data = response.json()
-            content = data["choices"][0]["message"]["content"]
-            
-            logger.info(f"LLM response: {len(content)} chars from {LLM_MODEL} via {_detect_provider()}")
-            return content
+            async for line in response.aiter_lines():
+                if line.startswith("data: "):
+                    data = line[6:]
+                    if data == "[DONE]":
+                        break
+                    try:
+                        import json
+                        chunk = json.loads(data)
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        content = delta.get("content", "")
+                        if content:
+                            yield content
+                    except (json.JSONDecodeError, IndexError, KeyError):
+                        continue
 
-    except httpx.TimeoutException:
-        raise RuntimeError(f"LLM request timed out (120s) — model: {LLM_MODEL}")
-    except httpx.ConnectError:
-        raise RuntimeError(f"Cannot connect to LLM at {LLM_BASE_URL} — check your configuration")
 
+# ═══ PROVIDER INFO ═══
 
 def get_provider_info() -> Dict:
-    """Return current LLM configuration (for health check / UI display)."""
+    """Return current LLM configuration and usage stats."""
     return {
         "configured": bool(LLM_API_KEY),
         "base_url": LLM_BASE_URL,
         "model": LLM_MODEL,
         "max_tokens": LLM_MAX_TOKENS,
         "temperature": LLM_TEMPERATURE,
+        "timeout_seconds": LLM_TIMEOUT,
         "provider": _detect_provider(),
+        "usage": _usage.to_dict(),
     }