Refactor LLM param resolution into adapters

Author: andrejvysny

agent/core/llm_params.py

@@ -5,14 +5,7 @@
 creating circular imports.
 """
 
-import os
-
-
-# HF router reasoning models only accept "low" | "medium" | "high" (e.g.
-# MiniMax M2 actually *requires* reasoning to be enabled). OpenAI's GPT-5
-# also accepts "minimal" for near-zero thinking. We map "minimal" to "low"
-# for HF so the user doesn't get a 400.
-_HF_ALLOWED_EFFORTS = {"low", "medium", "high"}
+from agent.core.provider_adapters import ADAPTERS
 
 
 def _resolve_llm_params(
@@ -50,27 +43,12 @@ def _resolve_llm_params(
       2. session.hf_token — the user's own token (CLI / OAuth / cache file).
       3. HF_TOKEN env — belt-and-suspenders fallback for CLI users.
     """
-    if model_name.startswith(("anthropic/", "openai/")):
-        params: dict = {"model": model_name}
-        if reasoning_effort:
-            params["reasoning_effort"] = reasoning_effort
-        return params
-
-    hf_model = model_name.removeprefix("huggingface/")
-    api_key = (
-        os.environ.get("INFERENCE_TOKEN")
-        or session_hf_token
-        or os.environ.get("HF_TOKEN")
-    )
-    params = {
-        "model": f"openai/{hf_model}",
-        "api_base": "https://router.huggingface.co/v1",
-        "api_key": api_key,
-    }
-    if os.environ.get("INFERENCE_TOKEN"):
-        params["extra_headers"] = {"X-HF-Bill-To": "huggingface"}
-    if reasoning_effort:
-        hf_level = "low" if reasoning_effort == "minimal" else reasoning_effort
-        if hf_level in _HF_ALLOWED_EFFORTS:
-            params["extra_body"] = {"reasoning_effort": hf_level}
-    return params
+    for adapter in ADAPTERS:
+        if adapter.matches(model_name):
+            return adapter.build_params(
+                model_name,
+                session_hf_token=session_hf_token,
+                reasoning_effort=reasoning_effort,
+            )
+
+    raise ValueError(f"Unsupported model id: {model_name}")

agent/core/provider_adapters.py

@@ -0,0 +1,79 @@
+"""Provider-specific LiteLLM parameter builders."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+class ProviderAdapter:
+    """Build LiteLLM kwargs for one family of model ids."""
+
+    def matches(self, model_name: str) -> bool:
+        raise NotImplementedError
+
+    def build_params(
+        self,
+        model_name: str,
+        session_hf_token: str | None = None,
+        reasoning_effort: str | None = None,
+    ) -> dict:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class NativeAdapter(ProviderAdapter):
+    prefixes: tuple[str, ...] = ("anthropic/", "openai/")
+
+    def matches(self, model_name: str) -> bool:
+        return model_name.startswith(self.prefixes)
+
+    def build_params(
+        self,
+        model_name: str,
+        session_hf_token: str | None = None,
+        reasoning_effort: str | None = None,
+    ) -> dict:
+        del session_hf_token
+        params: dict = {"model": model_name}
+        if reasoning_effort:
+            params["reasoning_effort"] = reasoning_effort
+        return params
+
+
+@dataclass(frozen=True)
+class HfRouterAdapter(ProviderAdapter):
+    allowed_efforts: tuple[str, ...] = ("low", "medium", "high")
+
+    def matches(self, model_name: str) -> bool:
+        return "/" in model_name and not model_name.startswith(
+            ("anthropic/", "openai/")
+        )
+
+    def build_params(
+        self,
+        model_name: str,
+        session_hf_token: str | None = None,
+        reasoning_effort: str | None = None,
+    ) -> dict:
+        hf_model = model_name.removeprefix("huggingface/")
+        inference_token = os.environ.get("INFERENCE_TOKEN")
+        api_key = inference_token or session_hf_token or os.environ.get("HF_TOKEN")
+        params = {
+            "model": f"openai/{hf_model}",
+            "api_base": "https://router.huggingface.co/v1",
+            "api_key": api_key,
+        }
+        if inference_token:
+            params["extra_headers"] = {"X-HF-Bill-To": "huggingface"}
+        if reasoning_effort:
+            hf_level = "low" if reasoning_effort == "minimal" else reasoning_effort
+            if hf_level in self.allowed_efforts:
+                params["extra_body"] = {"reasoning_effort": hf_level}
+        return params
+
+
+ADAPTERS: tuple[ProviderAdapter, ...] = (
+    NativeAdapter(),
+    HfRouterAdapter(),
+)

tests/test_provider_adapters.py

@@ -0,0 +1,35 @@
+from agent.core.llm_params import _resolve_llm_params
+
+
+def test_native_adapter_keeps_model_name():
+    params = _resolve_llm_params("anthropic/claude-opus-4-6", reasoning_effort="high")
+
+    assert params == {
+        "model": "anthropic/claude-opus-4-6",
+        "reasoning_effort": "high",
+    }
+
+
+def test_hf_adapter_builds_router_params(monkeypatch):
+    monkeypatch.setenv("HF_TOKEN", "hf-test")
+
+    params = _resolve_llm_params(
+        "moonshotai/Kimi-K2.6:novita", reasoning_effort="minimal"
+    )
+
+    assert params == {
+        "model": "openai/moonshotai/Kimi-K2.6:novita",
+        "api_base": "https://router.huggingface.co/v1",
+        "api_key": "hf-test",
+        "extra_body": {"reasoning_effort": "low"},
+    }
+
+
+def test_hf_adapter_adds_bill_to_header(monkeypatch):
+    monkeypatch.setenv("INFERENCE_TOKEN", "hf-space-token")
+    monkeypatch.delenv("HF_TOKEN", raising=False)
+
+    params = _resolve_llm_params("MiniMaxAI/MiniMax-M2.7")
+
+    assert params["extra_headers"] == {"X-HF-Bill-To": "huggingface"}
+    assert params["api_key"] == "hf-space-token"