fix: fail over when gemini quota is exhausted

Author: dipeshsingh2012

src/llm_runner.py

@@ -9,7 +9,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import json
 import logging
 import os
@@ -115,26 +114,33 @@ async def generate_response(
         if dry_run:
             return f"[DRY RUN / MOCK MODE] Generated response for input:\n{prompt_text}"
 
-        # Dispatch to provider
-        if self.provider == "anthropic" or (self.anthropic_api_key and not self.gemini_api_key):
-            try:
-                return await self._generate_anthropic(system_instruction, prompt_text)
-            except Exception as e:
-                logger.warning(f"Anthropic generation failed: {e}")
-
-        if self.provider == "openai" or (self.openai_api_key and not self.gemini_api_key):
-            try:
-                return await self._generate_openai(system_instruction, prompt_text)
-            except Exception as e:
-                logger.warning(f"OpenAI generation failed: {e}")
+        provider_generators = {
+            "gemini": lambda: self._generate_gemini(system_instruction, prompt_text, dry_run=dry_run, tier=tier),
+            "openai": lambda: self._generate_openai(system_instruction, prompt_text),
+            "anthropic": lambda: self._generate_anthropic(system_instruction, prompt_text),
+            "ollama": lambda: self._generate_ollama(system_instruction, prompt_text),
+        }
+        configured = {
+            "gemini": bool(self.gemini_api_key),
+            "openai": bool(self.openai_api_key),
+            "anthropic": bool(self.anthropic_api_key),
+            "ollama": bool(self.ollama_host),
+        }
+        provider_order = [self.provider] + [name for name, enabled in configured.items() if enabled and name != self.provider]
+        last_error: Optional[Exception] = None
 
-        if self.provider == "ollama":
+        for provider in provider_order:
+            generator = provider_generators.get(provider)
+            if not generator or (provider != "gemini" and not configured[provider]):
+                continue
             try:
-                return await self._generate_ollama(system_instruction, prompt_text)
-            except Exception as e:
-                logger.warning(f"Ollama generation failed: {e}")
+                return await generator()
+            except Exception as exc:
+                last_error = exc
+                logger.warning("%s generation failed; trying next configured provider: %s", provider, exc)
 
-        # Default / Fallback: Google Gemini
+        if last_error:
+            raise RuntimeError(f"All configured LLM providers failed. Last error: {last_error}") from last_error
         return await self._generate_gemini(system_instruction, prompt_text, dry_run=dry_run, tier=tier)
 
     def _get_gemini_candidate_models(self, tier: str = "fast") -> List[str]:
@@ -216,8 +222,6 @@ async def _generate_gemini(self, system_instruction: str, user_input: str, dry_r
                 except Exception as e:
                     last_error = e
                     print(f"[LLM:Gemini] ⚠️ Model {model_name} (SDK) failed: {e}")
-                    if "429" in str(e) or "RESOURCE_EXHAUSTED" in str(e):
-                        await asyncio.sleep(2)
 
             # 2. Try Gemini REST API
             if self.gemini_api_key:
@@ -241,8 +245,6 @@ async def _generate_gemini(self, system_instruction: str, user_input: str, dry_r
                         else:
                             last_error = f"HTTP {resp.status_code}: {resp.text}"
                             print(f"[LLM:Gemini-REST] ⚠️ Model {model_name} (REST) failed with HTTP {resp.status_code}: {resp.text[:120]}")
-                            if resp.status_code == 429:
-                                await asyncio.sleep(2)
                 except Exception as e:
                     last_error = e
                     print(f"[LLM:Gemini-REST] ⚠️ REST request for {model_name} failed: {e}")

tests/test_llm_runner.py

@@ -1,5 +1,6 @@
 import pytest
 from pathlib import Path
+from unittest.mock import AsyncMock
 from src.llm_runner import LLMRunner
 
 
@@ -31,3 +32,18 @@ async def test_generate_response_dry_run():
     )
     assert "DRY RUN" in response
     assert "Format issue #12" in response
+
+
+@pytest.mark.asyncio
+async def test_gemini_quota_fails_over_to_configured_provider():
+    runner = LLMRunner(provider="gemini")
+    runner.gemini_api_key = "gemini-key"
+    runner.openai_api_key = "openai-key"
+    runner._generate_gemini = AsyncMock(side_effect=RuntimeError("429 RESOURCE_EXHAUSTED quota exceeded"))
+    runner._generate_openai = AsyncMock(return_value="OpenAI fallback response")
+
+    response = await runner.generate_response("system", "input")
+
+    assert response == "OpenAI fallback response"
+    runner._generate_gemini.assert_awaited_once()
+    runner._generate_openai.assert_awaited_once()