"""Patch llm_params.py: add a DEDICATED BeatAPI provider branch. BEATAPI vs OpenRouter -- why this branch is separate and must stay separate ========================================================================= Every other model in this app except the HF Router / local-ollama ones is an *OpenRouter* model. They are all tagged with an `openai/` prefix, and _resolve_llm_params has a single catch-all that: 1. strips the `openai/` prefix, 2. points api_base at https://openrouter.ai/api/v1, 3. authenticates with OPENROUTER_API_KEY. BeatAPI (https://api.beatapi.io) is a *different provider* that happens to expose an OpenAI-compatible surface. It must therefore NOT reuse that branch: provider OpenRouter BeatAPI ----------- ----------------------------- ------------------------------ api_base https://openrouter.ai/api/v1 https://api.beatapi.io/v1 key env OPENROUTER_API_KEY BEATAPI_API_KEY model id vendor/model space-bunny-alpha (bare, no vendor prefix) effort unsupported (omitted) low/medium/high/xhigh/max via extra_body BeatAPI additionally: - does not understand the `openai/` prefix at all, so sending "openai/space-bunny-alpha" or "openai/stealth/space-bunny-alpha" 404s; - uses `space-bunny-alpha` as a *flat* model id, so we must strip our own `beatapi/` routing prefix before the request leaves the app; - rate-limits the free tier (1 req/min before first top-up, 10/min after, 1000/day) and returns HTTP 429 with Retry-After. Therefore BeatAPI models use the `beatapi/` prefix -- a namespace nothing else uses -- so this branch can never be shadowed by the `openai/` catch-all, and the OpenRouter branch can never accidentally strip a BeatAPI model id. If BEATAPI_API_KEY is unset we raise a clear, actionable error instead of silently sending an empty key (which BeatAPI answers with a bare 401 missing_api_key). Runs AFTER patch_models.py and patch_openrouter_fix.py. Idempotent. """ import ast FILE = "/app/agent/core/llm_params.py" BEATAPI_BASE_URL = "https://api.beatapi.io/v1" BEATAPI_MODEL_PREFIX = "beatapi/" with open(FILE) as f: c = f.read() if "BeatApiKeyMissingError" in c: print("OK: llm_params.py already contains BeatAPI routing (idempotent)") raise SystemExit(0) if "\nimport os\n" not in c: print("FAIL: expected `import os` in llm_params.py") raise SystemExit(1) # --- Insert the BeatAPI block before _resolve_llm_params --- anchor = "def _resolve_llm_params(\n" if anchor not in c: print("FAIL: could not find _resolve_llm_params definition") raise SystemExit(1) beatapi_block = f'''BEATAPI_BASE_URL = "{BEATAPI_BASE_URL}" BEATAPI_MODEL_PREFIX = "{BEATAPI_MODEL_PREFIX}" # BeatAPI accepts low/medium/high/xhigh/max (HF Router only low/medium/high). _BEATAPI_EFFORTS = {{"low", "medium", "high", "xhigh", "max"}} class BeatApiKeyMissingError(ValueError): """BEATAPI_API_KEY is not configured, so BeatAPI cannot be called. Raised before any network call so the UI shows an actionable message ("set BEATAPI_API_KEY") instead of an opaque 401 missing_api_key. """ def _beatapi_base_model(model_name: str) -> str: """Return the wire model id for a BeatAPI request. ``beatapi/space-bunny-alpha`` -> ``space-bunny-alpha`` BeatAPI model ids are flat; they must never carry our routing prefix. """ return model_name[len(BEATAPI_MODEL_PREFIX):].strip() def _resolve_beatapi_params( model_name: str, reasoning_effort: str | None = None, strict: bool = False, ) -> dict: """Build LiteLLM kwargs for a BeatAPI (``beatapi/``-prefixed) model. Mirrors the OpenRouter branch but targets api.beatapi.io, uses BEATAPI_API_KEY, forces LiteLLM's OpenAI-compatible client, and forwards BeatAPI's own reasoning_effort levels (it accepts xhigh and max, which the HF Router does not). """ base_model = _beatapi_base_model(model_name) if not base_model: raise ValueError(f"Missing BeatAPI model id: {{model_name!r}}") api_key = os.environ.get("BEATAPI_API_KEY", "").strip() if not api_key: raise BeatApiKeyMissingError( "BEATAPI_API_KEY is not set. BeatAPI models (beatapi/...) require a " "BeatAPI key from https://beatapi.io (Dashboard -> API Keys); " "set it as a Space secret named BEATAPI_API_KEY." ) params: dict = {{ "model": f"openai/{{base_model}}", "api_base": BEATAPI_BASE_URL, "api_key": api_key, # Force LiteLLM's OpenAI-compatible client. Without this, LiteLLM would # try to resolve a provider from the model string and raise # "LLM Provider NOT provided" (same class of bug as the OpenRouter fix). "custom_llm_provider": "openai", }} if reasoning_effort: level = reasoning_effort if level not in _BEATAPI_EFFORTS: if strict: raise UnsupportedEffortError( f"BeatAPI doesn't accept effort={{level!r}}" ) else: # BeatAPI reads reasoning_effort from the request body directly. params["extra_body"] = {{"reasoning_effort": level}} return params ''' c = c.replace(anchor, beatapi_block + anchor, 1) # --- Add the dispatch inside _resolve_llm_params, BEFORE the openai/ catch-all --- # The dispatch must sit after the local-model checks and before the OpenRouter # branch so `beatapi/` can never be swallowed by `openai/`. dispatch_anchor = " hf_model = normalized_model\n" if dispatch_anchor not in c: print("FAIL: could not find hf_model assignment in _resolve_llm_params") raise SystemExit(1) dispatch = """ # --- BeatAPI provider (beatapi/ prefix) ------------------------------- # NOTE: distinct from the OpenRouter branch below on api_base, API key, # model-id shape and reasoning_effort levels. Keep this check above the # openai/ catch-all so the two providers can never collide. if normalized_model.startswith(BEATAPI_MODEL_PREFIX): return _resolve_beatapi_params( normalized_model, reasoning_effort, strict ) """ c = c.replace(dispatch_anchor, dispatch + dispatch_anchor, 1) with open(FILE, "w") as f: f.write(c) try: ast.parse(c) print("OK: llm_params.py patched & syntax valid") except SyntaxError as e: print(f"FAIL: llm_params.py syntax error: {e}") raise # Sanity: the BeatAPI branch must appear before the openai/ catch-all. beat_i = c.find("startswith(BEATAPI_MODEL_PREFIX)") openai_i = c.find('startswith("openai/")') if beat_i != -1 and openai_i != -1: if beat_i < openai_i: print("OK: BeatAPI dispatch precedes the openai/ catch-all") else: print("FAIL: BeatAPI dispatch is AFTER the openai/ catch-all") raise SystemExit(1) print("DONE: BeatAPI routing branch added to llm_params.py")