Update API fallback logic for Groq and Gemini

baseline.py

@@ -17,6 +17,8 @@ import sys
 import json
 import argparse
 from typing import Dict, Any
+from dotenv import load_dotenv
+load_dotenv()
 
 from openai import OpenAI
 from environment import CodeReviewEnv
@@ -103,28 +105,70 @@ def parse_llm_response(content: str) -> Action:
     )
 
 
-def run_task(client: OpenAI, task_id: str, model: str, verbose: bool = True) -> Dict[str, Any]:
+def get_providers(model_arg):
+    providers = []
+
+    # 1. Groq
+    if os.environ.get("GROQ_API_KEY"):
+        providers.append({
+            "name": "Groq",
+            "api_key": os.environ.get("GROQ_API_KEY"),
+            "base_url": "https://api.groq.com/openai/v1",
+            "model": "llama-3.3-70b-versatile"
+        })
+        
+    # 2. Gemini
+    if os.environ.get("GEMINI_API_KEY"):
+        providers.append({
+            "name": "Gemini",
+            "api_key": os.environ.get("GEMINI_API_KEY"),
+            "base_url": "https://generativelanguage.googleapis.com/v1beta/openai/",
+            "model": "gemini-2.0-flash"
+        })
+        
+    # 3. Default
+    if not providers:
+        providers.append({
+            "name": "Default",
+            "api_key": API_KEY,
+            "base_url": API_BASE_URL,
+            "model": model_arg
+        })
+        
+    return providers
+
+
+def run_task(task_id: str, providers: list, verbose: bool = True) -> Dict[str, Any]:
     env = CodeReviewEnv(task_id=task_id)
     obs = env.reset(task_id=task_id)
 
     if verbose:
         print(f"\n{'='*60}\n  Task: {task_id.upper()} — {obs.file_name}\n{'='*60}")
 
-    try:
-        response = client.chat.completions.create(
-            model=model,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": build_user_prompt(obs.model_dump())},
-            ],
-            temperature=0.0,
-            max_tokens=2000,
-        )
-        action = parse_llm_response(response.choices[0].message.content)
-    except Exception as e:
+    action = None
+    
+    for provider in providers:
+        client = OpenAI(api_key=provider["api_key"], base_url=provider["base_url"])
         if verbose:
-            print(f"  [ERROR] {e}")
-        action = Action(comments=[], verdict="comment", summary=f"Error: {e}")
+            print(f"  [INFO] Attempting inference with {provider['name']} ({provider['model']})", flush=True)
+
+        try:
+            response = client.chat.completions.create(
+                model=provider["model"],
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": build_user_prompt(obs.model_dump())},
+                ],
+                temperature=0.0,
+                max_tokens=2000,
+            )
+            action = parse_llm_response(response.choices[0].message.content)
+            break # Success
+        except Exception as e:
+            if verbose:
+                print(f"  [ERROR] {provider['name']} failed: {e}")
+            action = Action(comments=[], verdict="comment", summary=f"Error: {e}")
+            continue # Try next provider
 
     _, reward, _, info = env.step(action)
     episode_history = [{
@@ -161,21 +205,19 @@ def main():
     parser.add_argument("--output-json", action="store_true")
     args = parser.parse_args()
 
-    if not API_KEY:
-        print("ERROR: No API_KEY or GEMINI_API_KEY env variable found.", file=sys.stderr)
-        sys.exit(1)
+    providers = get_providers(args.model)
 
-    client = OpenAI(api_key=API_KEY, base_url=API_BASE_URL)
     task_ids = [args.task] if args.task else ["easy", "medium", "hard"]
-    results = [run_task(client, t, args.model, not args.output_json) for t in task_ids]
+    results = [run_task(t, providers, not args.output_json) for t in task_ids]
 
     if args.output_json:
+        used_model = providers[0]['model'] if providers else args.model
         print(json.dumps({
             "scores": [{"task_id": r["task_id"], "task_name": r["task_name"],
                         "difficulty": r["difficulty"], "score": r["score"],
                         "feedback": r["feedback"]} for r in results],
-            "model_used": args.model,
-            "note": "Temperature=0. Provider: Google Gemini free tier.",
+            "model_used": used_model,
+            "note": "Temperature=0. Provider: Groq -> Gemini fallback.",
         }))
     else:
         print(f"\n{'='*60}\n  BASELINE SCORES\n{'='*60}")

free_review.py

@@ -1,13 +1,12 @@
 from openai import OpenAI
 import os
 import json
+import time
+from dotenv import load_dotenv
+load_dotenv()
 
 import inference
 
-GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
-GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
-DEFAULT_MODEL = os.environ.get("FREE_REVIEW_MODEL", "gemini-2.0-flash")
-
 SYSTEM_PROMPT = """You are an expert code reviewer with 15+ years 
 of experience. Review the provided code and identify ALL issues.
 
@@ -38,23 +37,43 @@ Respond ONLY with valid JSON, no markdown:
   "summary": "<summary>",
   "positive_aspects": ["<aspect1>", "<aspect2>"]
 }"""
-
 def review_free_code(code: str, language: str = "python", 
                      context: str = "") -> dict:
     """
-    Review any arbitrary code using Gemini.
+    Review any arbitrary code using Groq or Gemini.
     Returns structured findings without a grader score.
     """
-    api_key_to_use = GEMINI_API_KEY if GEMINI_API_KEY else inference._api_key
-    base_url_to_use = GEMINI_BASE_URL if GEMINI_API_KEY else inference.API_BASE_URL
+    providers = []
+    
+    # 1. Primary: Groq
+    if os.environ.get("GROQ_API_KEY"):
+        providers.append({
+            "name": "Groq",
+            "api_key": os.environ.get("GROQ_API_KEY"),
+            "base_url": "https://api.groq.com/openai/v1",
+            "model": "llama-3.3-70b-versatile"
+        })
+        
+    # 2. Fallback: Gemini
+    if os.environ.get("GEMINI_API_KEY"):
+        providers.append({
+            "name": "Gemini",
+            "api_key": os.environ.get("GEMINI_API_KEY"),
+            "base_url": "https://generativelanguage.googleapis.com/v1beta/openai/",
+            "model": "gemini-2.0-flash"
+        })
+        
+    # 3. Last Resort: Inference Proxy / Hackathon Default
+    if not providers and hasattr(inference, '_api_key') and inference._api_key:
+        providers.append({
+            "name": "Fallback Proxy",
+            "api_key": inference._api_key,
+            "base_url": inference.API_BASE_URL,
+            "model": inference.MODEL_NAME
+        })
 
-    if not api_key_to_use:
-        return {"error": "GEMINI_API_KEY not set and inference proxy key unavailable"}
-
-    client = OpenAI(
-        api_key=api_key_to_use,
-        base_url=base_url_to_use
-    )
+    if not providers:
+        return {"error": "API keys not set. Please add GROQ_API_KEY or GEMINI_API_KEY to your .env file."}
 
     user_prompt = f"""Language: {language}
 Context: {context if context else "General code review"}
@@ -66,30 +85,45 @@ Code to review:
 
 Review this code thoroughly and return JSON only."""
 
-    try:
-        response = client.chat.completions.create(
-            model=DEFAULT_MODEL,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": user_prompt}
-            ],
-            temperature=0.1,
-            max_tokens=3000,
-        )
-        content = response.choices[0].message.content.strip()
-        if content.startswith("```"):
-            lines = content.split("\n")
-            content = "\n".join(lines[1:])
-            if content.strip().endswith("```"):
-                content = content.strip()[:-3].strip()
-        return json.loads(content)
-    except json.JSONDecodeError:
-        return {"error": "Failed to parse AI response",
-                "raw": content[:500]}
-    except Exception as e:
-        err_str = str(e)
-        if "429" in err_str or "quota" in err_str.lower() or "RESOURCE_EXHAUSTED" in err_str:
-            return {"error": "API rate limit reached (429). Your Gemini free-tier quota is exhausted. "
-                             "Wait a minute and try again, or get a new API key at "
-                             "https://aistudio.google.com/app/apikey"}
-        return {"error": err_str}
+    last_error = ""
+
+    for provider in providers:
+        client = OpenAI(api_key=provider["api_key"], base_url=provider["base_url"])
+        print(f"Attempting review with {provider['name']} ({provider['model']})...")
+        
+        provider_attempts = 3
+        for attempt in range(provider_attempts):
+            try:
+                response = client.chat.completions.create(
+                    model=provider["model"],
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": user_prompt}
+                    ],
+                    temperature=0.1,
+                    max_tokens=3000,
+                )
+                content = response.choices[0].message.content.strip()
+                if content.startswith("```"):
+                    lines = content.split("\n")
+                    content = "\n".join(lines[1:])
+                    if content.strip().endswith("```"):
+                        content = content.strip()[:-3].strip()
+                return json.loads(content)
+            except json.JSONDecodeError:
+                return {"error": f"Failed to parse JSON from {provider['name']} model",
+                        "raw": content[:500]}
+            except Exception as e:
+                err_str = str(e)
+                last_error = err_str
+                # For Groq or Gemini 429 errors
+                if "429" in err_str or "quota" in err_str.lower() or "RESOURCE_EXHAUSTED" in err_str:
+                    if attempt < provider_attempts - 1:
+                        wait_time = 10 * (attempt + 1)
+                        print(f"[{provider['name']}] Rate limit hit. Waiting {wait_time}s before retry ({attempt+1}/{provider_attempts})...")
+                        time.sleep(wait_time)
+                        continue
+                print(f"[{provider['name']}] Request failed. Falling back to next provider if available.")
+                break # Exit retry loop and move to next provider
+                
+    return {"error": f"All fallback APIs failed. Last error: {last_error}"}

inference.py

@@ -15,6 +15,8 @@ import sys
 import json
 import argparse
 from typing import Dict, Any
+from dotenv import load_dotenv
+load_dotenv()
 
 from openai import OpenAI
 from environment import CodeReviewEnv
@@ -23,14 +25,13 @@ from models import Action, CodeComment, GraderInput
 
 
 # ── Exactly as required by the Pre-Submission Checklist ──────────────────
-API_BASE_URL = os.getenv("API_BASE_URL", "https://generativelanguage.googleapis.com/v1beta/openai/")
-MODEL_NAME   = os.getenv("MODEL_NAME", "gemini-2.0-flash")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.groq.com/openai/v1")
+MODEL_NAME   = os.getenv("MODEL_NAME", "llama-3.3-70b-versatile")
 HF_TOKEN     = os.getenv("HF_TOKEN")
 LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
 
 # Use HF_TOKEN if provided by validator, else fall back to GEMINI_API_KEY
-_api_key = HF_TOKEN or os.getenv("GEMINI_API_KEY", "AIzaSyA92Np6UCnjIDhyKr-xFWcPDgWwcZ9Q63M")
-
+_api_key = HF_TOKEN or os.getenv("GROQ_API_KEY") or os.getenv("GEMINI_API_KEY", "")
 
 SYSTEM_PROMPT = """You are an expert code reviewer. You will be given a code diff from a pull request.
 Your job is to identify ALL bugs, security vulnerabilities, performance issues, and logic errors.
@@ -100,7 +101,49 @@ def parse_llm_response(content: str) -> Action:
     )
 
 
-def run_task(client: OpenAI, task_id: str, model: str, verbose: bool = True) -> Dict[str, Any]:
+def get_providers(model_arg):
+    providers = []
+    
+    # 1. Hackathon Proxy environment (if injected by validator)
+    if os.getenv("HF_TOKEN") and os.getenv("API_BASE_URL") and "generative" not in os.getenv("API_BASE_URL", "") and "groq" not in os.getenv("API_BASE_URL", ""):
+        providers.append({
+            "name": "Hackathon Proxy",
+            "api_key": os.getenv("HF_TOKEN"),
+            "base_url": os.getenv("API_BASE_URL"),
+            "model": os.getenv("MODEL_NAME", model_arg)
+        })
+
+    # 2. Main Provider: Groq
+    if os.environ.get("GROQ_API_KEY"):
+        providers.append({
+            "name": "Groq",
+            "api_key": os.environ.get("GROQ_API_KEY"),
+            "base_url": "https://api.groq.com/openai/v1",
+            "model": "llama-3.3-70b-versatile"
+        })
+        
+    # 3. Fallback: Gemini
+    if os.environ.get("GEMINI_API_KEY"):
+        providers.append({
+            "name": "Gemini",
+            "api_key": os.environ.get("GEMINI_API_KEY"),
+            "base_url": "https://generativelanguage.googleapis.com/v1beta/openai/",
+            "model": "gemini-2.0-flash"
+        })
+        
+    # Fallback to defaults
+    if not providers:
+        providers.append({
+            "name": "Default",
+            "api_key": _api_key,
+            "base_url": API_BASE_URL,
+            "model": model_arg
+        })
+        
+    return providers
+
+
+def run_task(task_id: str, providers: list, verbose: bool = True) -> Dict[str, Any]:
     env = CodeReviewEnv(task_id=task_id)
     obs = env.reset(task_id=task_id)
 
@@ -109,23 +152,35 @@ def run_task(client: OpenAI, task_id: str, model: str, verbose: bool = True) ->
 
     # REQUIRED: [START] block
     print(f"[START] task={task_id}", flush=True)
-
-    try:
-        # All LLM calls use OpenAI client configured via checklist variables
-        response = client.chat.completions.create(
-            model=model,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": build_user_prompt(obs.model_dump())},
-            ],
-            temperature=0.0,
-            max_tokens=2000,
-        )
-        action = parse_llm_response(response.choices[0].message.content)
-    except Exception as e:
+    
+    action = None
+    
+    for provider in providers:
+        client = OpenAI(api_key=provider["api_key"], base_url=provider["base_url"])
         if verbose:
-            print(f"  [ERROR] {e}", flush=True)
-        action = Action(comments=[], verdict="comment", summary=f"Error: {e}")
+            print(f"  [INFO] Attempting inference with {provider['name']} ({provider['model']})", flush=True)
+            
+        try:
+            response = client.chat.completions.create(
+                model=provider["model"],
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": build_user_prompt(obs.model_dump())},
+                ],
+                temperature=0.0,
+                max_tokens=2000,
+            )
+            action = parse_llm_response(response.choices[0].message.content)
+            break # Success, exit provider loop
+        except Exception as e:
+            err_str = str(e)
+            if verbose:
+                print(f"  [ERROR] {provider['name']} failed: {err_str}", flush=True)
+            if "429" in err_str or "quota" in err_str.lower() or "RESOURCE_EXHAUSTED" in err_str:
+                if verbose:
+                    print(f"  [INFO] Rate limit reached on {provider['name']}, switching to fallback...", flush=True)
+            action = Action(comments=[], verdict="comment", summary=f"Error: {e}")
+            continue # Try next provider
 
     _, reward, _, info = env.step(action)
 
@@ -169,22 +224,20 @@ def main():
     parser.add_argument("--output-json", action="store_true")
     args = parser.parse_args()
 
-    # All LLM calls use OpenAI client configured via checklist variables
-    client = OpenAI(
-        api_key=_api_key,
-        base_url=API_BASE_URL,
-    )
+    providers = get_providers(args.model)
 
     task_ids = [args.task] if args.task else ["easy", "medium", "hard"]
-    results = [run_task(client, t, args.model, not args.output_json) for t in task_ids]
+    results = [run_task(t, providers, not args.output_json) for t in task_ids]
 
     if args.output_json:
+        # Just grab the first provider's model as a proxy for what was used across tasks 
+        used_model = providers[0]['model'] if providers else args.model
         print(json.dumps({
             "scores": [{"task_id": r["task_id"], "task_name": r["task_name"],
                         "difficulty": r["difficulty"], "score": r["score"],
                         "feedback": r["feedback"]} for r in results],
-            "model_used": args.model,
-            "note": "Temperature=0. Uses API_BASE_URL + HF_TOKEN from environment.",
+            "model_used": used_model,
+            "note": "Temperature=0. Uses environment variables with Groq->Gemini fallback.",
         }), flush=True)
     else:
         print(f"\n{'='*60}\n  BASELINE SCORES\n{'='*60}", flush=True)