Download research/scripts/gen_llm.py from FrontierCS/Frontier-CS: direct link, hf CLI and curl.
- Browser
- Download file 5.77 kB
-
https://huggingface.co/datasets/FrontierCS/Frontier-CS/resolve/main/research/scripts/gen_llm.py
- Command line
-
hf download hf://datasets/FrontierCS/Frontier-CS/research/scripts/gen_llm.py
-
curl -L -o gen_llm.py https://huggingface.co/datasets/FrontierCS/Frontier-CS/resolve/main/research/scripts/gen_llm.py
5.77 kB
| """LLM client instantiation and provider detection.""" | |
| import os | |
| import threading | |
| from typing import Any, Dict, Optional, Tuple | |
| from llm_interface import ( | |
| LLMInterface, | |
| GPT, | |
| Gemini, | |
| Claude, | |
| Claude_Opus, | |
| Claude_Sonnet_4_5, | |
| DeepSeek, | |
| Grok, | |
| ) | |
| # Thread-safe storage for model configuration summary | |
| MODEL_CONFIG_SUMMARY: Dict[str, Dict[str, Any]] = {} | |
| MODEL_CONFIG_LOCK = threading.Lock() | |
| def infer_provider_and_model(model: str) -> Tuple[str, str]: | |
| """Parse model string into provider hint and actual model name.""" | |
| normalized = model.strip() | |
| if "/" in normalized: | |
| provider, actual_model = normalized.split("/", 1) | |
| else: | |
| provider, actual_model = "", normalized | |
| return provider.lower(), actual_model.strip() | |
| def detect_provider(model: str, actual_model_lower: Optional[str] = None) -> str: | |
| """Detect the provider for a given model string.""" | |
| provider_hint, actual_model = infer_provider_and_model(model) | |
| actual_lower = actual_model_lower or actual_model.lower() | |
| if (provider_hint in {"", "openai", "azure", "azure_openai"}) and actual_lower.startswith("gpt"): | |
| return "openai" | |
| if provider_hint in {"gemini", "google"} or "gemini" in actual_lower: | |
| return "google" | |
| if provider_hint == "anthropic" or "claude" in actual_lower: | |
| return "anthropic" | |
| if provider_hint == "xai" or "grok" in actual_lower: | |
| return "xai" | |
| if provider_hint == "deepseek" or "deepseek" in actual_lower: | |
| return "deepseek" | |
| return provider_hint or "openai" | |
| def instantiate_llm_client( | |
| model: str, | |
| *, | |
| is_reasoning_model: bool, | |
| timeout: float, | |
| base_url: Optional[str], | |
| api_key: Optional[str], | |
| ) -> Tuple[LLMInterface, Dict[str, Any]]: | |
| """Create an LLM client instance for the given model.""" | |
| provider_hint, actual_model = infer_provider_and_model(model) | |
| actual_model_lower = actual_model.lower() | |
| provider = detect_provider(model, actual_model_lower) | |
| config: Dict[str, Any] = { | |
| "requested_model": model, | |
| "actual_model": actual_model, | |
| "reasoning_mode": is_reasoning_model, | |
| } | |
| # OpenRouter special-case for Gemini 3 | |
| if provider == "openrouter": | |
| requested_lower = model.lower().strip() | |
| if requested_lower in {"gemini 3", "gemini3"}: | |
| or_slug = "google/gemini-3-pro-preview" | |
| elif "/" in model: | |
| or_slug = model | |
| else: | |
| if actual_model_lower.startswith("gemini-3"): | |
| or_slug = f"google/{actual_model}" | |
| else: | |
| or_slug = "google/gemini-3-pro-preview" | |
| openrouter_base = "https://openrouter.ai/api/v1" | |
| resolved_key = api_key or os.getenv("OPENROUTER_API_KEY") | |
| reasoning_effort = "high" if is_reasoning_model else None | |
| client = GPT( | |
| model=or_slug, | |
| reasoning_effort=reasoning_effort, | |
| timeout=timeout, | |
| base_url=openrouter_base, | |
| api_key=resolved_key, | |
| ) | |
| config.update({ | |
| "provider": "openrouter", | |
| "interface": client.__class__.__name__, | |
| "reasoning_effort": reasoning_effort, | |
| "base_url": openrouter_base, | |
| "openrouter_model_slug": or_slug, | |
| }) | |
| elif provider == "openai": | |
| reasoning_effort = "high" if is_reasoning_model else None | |
| client = GPT( | |
| model=actual_model, | |
| reasoning_effort=reasoning_effort, | |
| timeout=timeout, | |
| base_url=base_url, | |
| api_key=api_key, | |
| ) | |
| config.update({ | |
| "provider": provider, | |
| "interface": client.__class__.__name__, | |
| "reasoning_effort": reasoning_effort, | |
| "base_url": base_url or "https://api.openai.com/v1", | |
| }) | |
| elif provider == "google": | |
| client = Gemini(model=actual_model, timeout=timeout, api_key=api_key) | |
| config.update({ | |
| "provider": provider, | |
| "interface": client.__class__.__name__, | |
| "reasoning_effort": None, | |
| }) | |
| elif provider == "anthropic": | |
| if "claude-sonnet-4-5" in actual_model_lower: | |
| client = Claude_Sonnet_4_5(model=actual_model, api_key=api_key) | |
| elif "claude-opus" in actual_model_lower: | |
| client = Claude_Opus(model=actual_model, api_key=api_key) | |
| else: | |
| client = Claude(model=actual_model, api_key=api_key) | |
| config.update({ | |
| "provider": provider, | |
| "interface": client.__class__.__name__, | |
| "reasoning_effort": "thinking-enabled", | |
| }) | |
| elif provider == "xai": | |
| reasoning_effort = "high" if is_reasoning_model else None | |
| client = Grok( | |
| model=actual_model, | |
| reasoning_effort=reasoning_effort, | |
| timeout=timeout, | |
| api_key=api_key, | |
| ) | |
| config.update({ | |
| "provider": provider, | |
| "interface": client.__class__.__name__, | |
| "reasoning_effort": reasoning_effort, | |
| "base_url": "https://api.x.ai/v1", | |
| }) | |
| elif provider == "deepseek": | |
| client = DeepSeek( | |
| model=actual_model, | |
| timeout=timeout, | |
| api_key=api_key, | |
| ) | |
| config.update({ | |
| "provider": provider, | |
| "interface": client.__class__.__name__, | |
| "reasoning_effort": None, | |
| "base_url": "https://api.deepseek.com", | |
| }) | |
| else: | |
| raise ValueError(f"Unsupported model identifier '{model}' for llm_interface integration.") | |
| if api_key: | |
| config["api_key_hint"] = f"***{api_key[-6:]}" | |
| with MODEL_CONFIG_LOCK: | |
| MODEL_CONFIG_SUMMARY[model] = config | |
| return client, config | |