Spaces:
Running
Running
Download patch_beatapi_routing.py from bep40/ml-intern: direct link, hf CLI and curl.
- Browser
- Download file 6.98 kB
-
https://huggingface.co/spaces/bep40/ml-intern/resolve/main/patch_beatapi_routing.py
- Command line
-
hf download hf://spaces/bep40/ml-intern/patch_beatapi_routing.py
-
curl -L -o patch_beatapi_routing.py https://huggingface.co/spaces/bep40/ml-intern/resolve/main/patch_beatapi_routing.py
6.98 kB
| """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") | |