Add backend/app/services/llm_provider.py — universal LLM provider + complete API

backend/app/services/llm_provider.py

@@ -1,118 +1,124 @@
 """
-TestGenius AI — LLM Provider
-==============================
-Abstraction layer for AI model providers (Gemini, Groq, OpenAI).
-Supports fallback chain: Gemini → Groq → OpenAI.
+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.
 """
 
 import os
-import json
 import logging
-from typing import Optional, Dict, Any
+import httpx
+from typing import Optional, Dict
 
 logger = logging.getLogger(__name__)
 
-# ─── Provider Implementations ─────────────────────────────────────────────────
-
-async def call_gemini(prompt: str, system_prompt: str, config: Dict = None) -> str:
-    """Call Google Gemini API."""
-    import google.generativeai as genai
-
-    api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
-    if not api_key:
-        raise ValueError("GEMINI_API_KEY not set")
-
-    genai.configure(api_key=api_key)
-    model = genai.GenerativeModel("gemini-2.0-flash")
-
-    response = model.generate_content(
-        f"{system_prompt}\n\n{prompt}",
-        generation_config=genai.types.GenerationConfig(
-            temperature=0.3,
-            max_output_tokens=8192,
-        ),
-    )
-    return response.text
-
-
-async def call_groq(prompt: str, system_prompt: str, config: Dict = None) -> str:
-    """Call Groq API (Llama 3.3 70B)."""
-    import httpx
-
-    api_key = os.environ.get("GROQ_API_KEY")
-    if not api_key:
-        raise ValueError("GROQ_API_KEY not set")
-
-    async with httpx.AsyncClient(timeout=60.0) as client:
-        resp = await client.post(
-            "https://api.groq.com/openai/v1/chat/completions",
-            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
-            json={
-                "model": "llama-3.3-70b-versatile",
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt},
-                ],
-                "temperature": 0.3,
-                "max_tokens": 8192,
-            },
-        )
-        resp.raise_for_status()
-        return resp.json()["choices"][0]["message"]["content"]
-
-
-async def call_openai(prompt: str, system_prompt: str, config: Dict = None) -> str:
-    """Call OpenAI API."""
-    import httpx
-
-    api_key = os.environ.get("OPENAI_API_KEY")
-    if not api_key:
-        raise ValueError("OPENAI_API_KEY not set")
-
-    async with httpx.AsyncClient(timeout=60.0) as client:
-        resp = await client.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
-            json={
-                "model": "gpt-4o-mini",
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt},
-                ],
-                "temperature": 0.3,
-                "max_tokens": 8192,
-            },
-        )
-        resp.raise_for_status()
-        return resp.json()["choices"][0]["message"]["content"]
-
+# ═══ CONFIGURATION FROM .env ═══
 
-# ─── Provider Chain (with fallback) ──────────────────────────────────────────
+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"))
 
-PROVIDERS = [
-    ("gemini", call_gemini),
-    ("groq", call_groq),
-    ("openai", call_openai),
-]
 
-async def generate_with_llm(prompt: str, system_prompt: str, preferred_provider: Optional[str] = None) -> str:
+async def generate_with_llm(
+    prompt: str,
+    system_prompt: str,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None,
+) -> str:
     """
-    Generate text using LLM with automatic fallback.
-    Tries: preferred → Gemini → Groq → OpenAI.
+    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)
     """
-    providers = list(PROVIDERS)
-    if preferred_provider:
-        providers.sort(key=lambda p: 0 if p[0] == preferred_provider else 1)
-
-    errors = []
-    for name, fn in providers:
-        try:
-            result = await fn(prompt, system_prompt)
-            logger.info(f"LLM response from {name} ({len(result)} chars)")
-            return result
-        except Exception as e:
-            errors.append(f"{name}: {str(e)[:100]}")
-            logger.warning(f"Provider {name} failed: {e}")
-            continue
-
-    raise RuntimeError(f"All LLM providers failed: {errors}")
+    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"
+        )
+
+    url = f"{LLM_BASE_URL.rstrip('/')}/chat/completions"
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {LLM_API_KEY}",
+    }
+    
+    # Some providers need extra headers
+    if "openrouter" in LLM_BASE_URL:
+        headers["HTTP-Referer"] = "https://testgenius-ai.app"
+        headers["X-Title"] = "TestGenius AI"
+
+    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,
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(url, headers=headers, json=payload)
+
+            if response.status_code == 429:
+                logger.warning("Rate limited — retrying after 2s")
+                import asyncio
+                await asyncio.sleep(2)
+                response = await client.post(url, headers=headers, json=payload)
+
+            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}")
+
+            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
+
+    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")
+
+
+def get_provider_info() -> Dict:
+    """Return current LLM configuration (for health check / UI display)."""
+    return {
+        "configured": bool(LLM_API_KEY),
+        "base_url": LLM_BASE_URL,
+        "model": LLM_MODEL,
+        "max_tokens": LLM_MAX_TOKENS,
+        "temperature": LLM_TEMPERATURE,
+        "provider": _detect_provider(),
+    }
+
+
+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"
+    return "Custom"