| """API key pool management for solution generation.""" | |
| import os | |
| import threading | |
| import time | |
| from typing import Dict, List, Optional, Tuple | |
| PROVIDER_ENV_KEY_MAP: Dict[str, List[str]] = { | |
| "openai": ["OPENAI_API_KEY"], | |
| "google": ["GOOGLE_API_KEY", "GEMINI_API_KEY"], | |
| "anthropic": ["ANTHROPIC_API_KEY"], | |
| "xai": ["XAI_API_KEY", "GROK_API_KEY"], | |
| "deepseek": ["DEEPSEEK_API_KEY"], | |
| "openrouter": ["OPENROUTER_API_KEY"], | |
| } | |
| class APIKeyPool: | |
| """Thread-safe pool of API keys with backoff handling.""" | |
| def __init__(self, keys: List[str], *, name: str): | |
| self.name = name | |
| self._states = [ | |
| { | |
| "key": key, | |
| "failures": 0, | |
| "disabled": False, | |
| "backoff_until": 0.0, | |
| } | |
| for key in keys | |
| ] | |
| self._lock = threading.Lock() | |
| self._index = 0 | |
| def acquire(self) -> Tuple[Optional[str], Optional[int]]: | |
| """Acquire an available API key from the pool.""" | |
| with self._lock: | |
| if not self._states: | |
| return None, None | |
| now = time.time() | |
| for _ in range(len(self._states)): | |
| idx = self._index % len(self._states) | |
| self._index += 1 | |
| state = self._states[idx] | |
| if state["disabled"]: | |
| continue | |
| if state["backoff_until"] > now: | |
| continue | |
| return state["key"], idx | |
| return None, None | |
| def report_success(self, idx: Optional[int]) -> None: | |
| """Report successful API call for a key.""" | |
| if idx is None: | |
| return | |
| with self._lock: | |
| if 0 <= idx < len(self._states): | |
| state = self._states[idx] | |
| state["failures"] = 0 | |
| state["backoff_until"] = 0.0 | |
| def report_failure(self, idx: Optional[int], error: Optional[str]) -> None: | |
| """Report failed API call for a key.""" | |
| if idx is None: | |
| return | |
| with self._lock: | |
| if not (0 <= idx < len(self._states)): | |
| return | |
| state = self._states[idx] | |
| state["failures"] += 1 | |
| reason = (error or "").lower() | |
| fatal_markers = ("invalid", "unauthorized", "forbidden", "permission", "auth") | |
| if any(marker in reason for marker in fatal_markers): | |
| if not state["disabled"]: | |
| print(f"Disabling API key for {self.name}: appears invalid/unauthorized") | |
| state["disabled"] = True | |
| state["backoff_until"] = float("inf") | |
| return | |
| delay: int = min(600, 60 * state["failures"]) | |
| state["backoff_until"] = max(state["backoff_until"], time.time() + delay) | |
| print( | |
| f"Backing off {delay:.0f}s for {self.name} key due to failure (count={state['failures']})." | |
| ) | |
| def size(self) -> int: | |
| """Return the number of keys in the pool.""" | |
| with self._lock: | |
| return len(self._states) | |
| def _matches_env_base(key_name: str, base: str) -> bool: | |
| """Check if an environment variable name matches a base name pattern.""" | |
| if key_name == base: | |
| return True | |
| if key_name.startswith(base): | |
| suffix = key_name[len(base):] | |
| if not suffix: | |
| return True | |
| if suffix.isdigit(): | |
| return True | |
| if suffix.startswith(('_', '-')): | |
| return True | |
| return False | |
| def _collect_provider_keys(provider: str, base_names: List[str]) -> List[str]: | |
| """Collect all API keys for a provider from environment variables.""" | |
| keys: List[str] = [] | |
| seen: set[str] = set() | |
| for env_name, value in os.environ.items(): | |
| if not value: | |
| continue | |
| for base in base_names: | |
| if _matches_env_base(env_name, base): | |
| key_value = value.strip() | |
| if key_value and key_value not in seen: | |
| seen.add(key_value) | |
| keys.append(key_value) | |
| return keys | |
| def build_key_pools(primary_openai_key: Optional[str] = None) -> Dict[str, APIKeyPool]: | |
| """Build API key pools for all providers.""" | |
| pools: Dict[str, APIKeyPool] = {} | |
| for provider, bases in PROVIDER_ENV_KEY_MAP.items(): | |
| keys = _collect_provider_keys(provider, bases) | |
| if provider == "openai" and primary_openai_key: | |
| key = primary_openai_key.strip() | |
| if key and key not in keys: | |
| keys.insert(0, key) | |
| if keys: | |
| pools[provider] = APIKeyPool(keys, name=provider) | |
| return pools | |
| def get_fallback_api_key(provider: str, default_key: Optional[str] = None) -> Optional[str]: | |
| """Get a fallback API key for a provider without using the pool.""" | |
| candidate_keys: List[Optional[str]] = [] | |
| if provider == "openai": | |
| candidate_keys.extend([ | |
| default_key, | |
| os.getenv("OPENAI_API_KEY"), | |
| os.getenv("OPENAI_API_KEY2"), | |
| os.getenv("OPENAI_API_KEY_2"), | |
| ]) | |
| elif provider == "openrouter": | |
| candidate_keys.extend([ | |
| os.getenv("OPENROUTER_API_KEY"), | |
| os.getenv("OPENROUTER_API_KEY2"), | |
| os.getenv("OPENROUTER_KEY"), | |
| ]) | |
| elif provider == "google": | |
| candidate_keys.extend([ | |
| os.getenv("GOOGLE_API_KEY"), | |
| os.getenv("GOOGLE_API_KEY2"), | |
| os.getenv("GEMINI_API_KEY"), | |
| os.getenv("GEMINI_API_KEY2"), | |
| ]) | |
| elif provider == "anthropic": | |
| candidate_keys.extend([ | |
| os.getenv("ANTHROPIC_API_KEY"), | |
| os.getenv("ANTHROPIC_API_KEY2"), | |
| ]) | |
| elif provider == "xai": | |
| candidate_keys.extend([ | |
| os.getenv("XAI_API_KEY"), | |
| os.getenv("XAI_API_KEY2"), | |
| os.getenv("GROK_API_KEY"), | |
| os.getenv("GROK_API_KEY2"), | |
| ]) | |
| elif provider == "deepseek": | |
| candidate_keys.extend([ | |
| os.getenv("DEEPSEEK_API_KEY"), | |
| os.getenv("DEEPSEEK_API_KEY2"), | |
| ]) | |
| return next((k for k in candidate_keys if k), None) | |