feat: llm_provider.py v2 with backoff, streaming, token tracking

backend/app/services/llm_provider.py

@@ -1,26 +1,21 @@
 """
-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
+TestGenius AI — Universal LLM Provider (v2 — Production Ready)
+================================================================
+Works with ANY OpenAI-compatible API.
+Features: exponential backoff, streaming, token tracking, proper timeouts.
 """
 
 import os
 import time
+import json
 import logging
 import asyncio
 import httpx
-from typing import Optional, Dict, Any
+from typing import Optional, Dict
 from dataclasses import dataclass, field
 
 logger = logging.getLogger(__name__)
 
-# ═══ 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")
@@ -29,18 +24,14 @@ 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:
@@ -59,33 +50,22 @@ class UsageStats:
             "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(),
+            "estimated_cost_usd": round(self.total_prompt_tokens * 3e-7 + self.total_completion_tokens * 6e-7, 4),
         }
 
-    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,
@@ -93,25 +73,13 @@ async def generate_with_llm(
     max_tokens: Optional[int] = None,
     timeout: Optional[float] = None,
 ) -> str:
-    """
-    Generate text using ANY OpenAI-compatible LLM provider.
-    FIX: Exponential backoff, token tracking, better error handling.
-    """
+    """Generate text with exponential backoff retry."""
     if not LLM_API_KEY:
-        raise RuntimeError(
-            "LLM_API_KEY not set. Configure in .env:\n"
-            "  LLM_BASE_URL=https://api.groq.com/openai/v1\n"
-            "  LLM_API_KEY=your-key\n"
-            "  LLM_MODEL=llama-3.3-70b-versatile"
-        )
+        raise RuntimeError("LLM_API_KEY not set. Configure in .env")
 
     url = f"{LLM_BASE_URL.rstrip('/')}/chat/completions"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {LLM_API_KEY}",
-    }
+    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {LLM_API_KEY}"}
 
-    # Provider-specific headers
     if "openrouter" in LLM_BASE_URL:
         headers["HTTP-Referer"] = "https://testgenius-ai.app"
         headers["X-Title"] = "TestGenius AI"
@@ -128,76 +96,59 @@ async def generate_with_llm(
 
     request_timeout = timeout or LLM_TIMEOUT
     start_time = time.time()
-
-    # 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
+                        wait = (2 ** attempt) + 1
                         retry_after = response.headers.get("Retry-After")
                         if retry_after:
                             try:
-                                wait_time = min(int(retry_after), 30)
+                                wait = 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)
+                        logger.warning(f"Rate limited. Retry {attempt+1}/{max_retries} in {wait}s")
+                        await asyncio.sleep(wait)
                         continue
-                    else:
-                        _usage.total_errors += 1
-                        raise RuntimeError(f"Rate limited after {max_retries} retries. Try again later.")
+                    _usage.total_errors += 1
+                    raise RuntimeError("Rate limited after all retries")
 
                 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)
+                        await asyncio.sleep((2 ** attempt) + 1)
                         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}")
+                    raise RuntimeError(f"LLM API error {response.status_code}: {response.text[:200]}")
 
                 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()}"
-                )
-
+                logger.info(f"LLM: {len(content)} chars, {usage.get('total_tokens', '?')} tokens, {latency:.0f}ms")
                 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)")
-
+            raise RuntimeError(f"LLM timed out after {max_retries} retries")
         except httpx.ConnectError:
             _usage.total_errors += 1
             raise RuntimeError(f"Cannot connect to LLM at {LLM_BASE_URL}")
@@ -206,31 +157,16 @@ async def generate_with_llm(
     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.
-    """
+async def generate_with_llm_streaming(prompt: str, system_prompt: str, temperature: Optional[float] = None, max_tokens: Optional[int] = None):
+    """Streaming generation — yields chunks as they arrive."""
     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}",
-    }
-
+    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},
-        ],
+        "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,
@@ -239,28 +175,22 @@ async def generate_with_llm_streaming(
     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:
-                raise RuntimeError(f"LLM streaming error: {response.status_code}")
-
+                raise RuntimeError(f"Streaming error: {response.status_code}")
             async for line in response.aiter_lines():
                 if line.startswith("data: "):
-                    data = line[6:]
-                    if data == "[DONE]":
+                    data_str = line[6:]
+                    if data_str == "[DONE]":
                         break
                     try:
-                        import json
-                        chunk = json.loads(data)
-                        delta = chunk.get("choices", [{}])[0].get("delta", {})
-                        content = delta.get("content", "")
+                        chunk = json.loads(data_str)
+                        content = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
                         if content:
                             yield content
                     except (json.JSONDecodeError, IndexError, KeyError):
                         continue
 
 
-# ═══ PROVIDER INFO ═══
-
 def get_provider_info() -> Dict:
-    """Return current LLM configuration and usage stats."""
     return {
         "configured": bool(LLM_API_KEY),
         "base_url": LLM_BASE_URL,
@@ -275,14 +205,11 @@ def get_provider_info() -> Dict:
 
 def _detect_provider() -> str:
     url = LLM_BASE_URL.lower()
-    if "openai.com" in url: return "OpenAI"
-    if "featherless" in url: return "Featherless"
-    if "groq.com" in url: return "Groq"
-    if "together" in url: return "Together.ai"
-    if "deepseek" in url: return "DeepSeek"
-    if "openrouter" in url: return "OpenRouter"
-    if "mistral" in url: return "Mistral"
-    if "localhost:11434" in url: return "Ollama"
-    if "localhost:1234" in url: return "LM Studio"
-    if "localhost" in url: return "Local"
+    providers = [("openai.com", "OpenAI"), ("featherless", "Featherless"), ("groq.com", "Groq"),
+                 ("together", "Together.ai"), ("deepseek", "DeepSeek"), ("openrouter", "OpenRouter"),
+                 ("mistral", "Mistral"), ("localhost:11434", "Ollama"), ("localhost:1234", "LM Studio"),
+                 ("localhost", "Local")]
+    for key, name in providers:
+        if key in url:
+            return name
     return "Custom"