Implement user-billed model policy (#289)

* Implement user-billed model policy

- bill hosted inference to user tokens and remove subsidy quota state

- switch web and CLI defaults and remove Sonnet from model lists

- add plan-aware inference credit CTAs

Co-authored-by: OpenAI Codex <codex@openai.com>

* Recommend Opus in model picker

Co-authored-by: OpenAI Codex <codex@openai.com>

* Remove minimum plan from model config

Co-authored-by: OpenAI Codex <codex@openai.com>

* Link message failures to Space discussions

Co-authored-by: OpenAI Codex <codex@openai.com>

* Remove compatibility quota endpoint

Co-authored-by: OpenAI Codex <codex@openai.com>

* Remove obsolete bill_to_user argument

Co-authored-by: OpenAI Codex <codex@openai.com>

* Remove model tier metadata

Co-authored-by: OpenAI Codex <codex@openai.com>

* Remove model picker provider subtitles

Co-authored-by: OpenAI Codex <codex@openai.com>

---------

Co-authored-by: OpenAI Codex <codex@openai.com>

AGENTS.md

@@ -13,7 +13,7 @@ Notes:
 - Vite proxies `/api` and `/auth` to `http://localhost:7860`.
 - If `127.0.0.1:7860` is already owned by another local process, binding the backend to `::1` lets the Vite proxy resolve `localhost` cleanly.
 - Prefer `npm ci` over `npm install` for setup, since `npm install` may rewrite `frontend/package-lock.json` metadata depending on npm version.
-- Production defaults to Claude Sonnet 4.6 through the HF Router (`anthropic/claude-sonnet-4-6:fal-ai`). Non-local LLM calls use `https://router.huggingface.co/v1` with Hugging Face tokens. Subsidized premium calls use the Space/operator `INFERENCE_TOKEN` plus `X-HF-Bill-To` from `HF_BILL_TO` (default `smolagents`); Opus and GPT-5.5 daily sessions are Pro-only, and after the daily allowance, premium calls bill the user's own HF token. For local development, set `HF_TOKEN` and optionally `ML_INTERN_DEFAULT_MODEL_ID`.
+- Non-local LLM calls use `https://router.huggingface.co/v1` with the active Hugging Face user's token. Web sessions default to Kimi K2.6 for free users and Claude Opus 4.8 for Pro users; the CLI default is Claude Opus 4.8. For local development, set `HF_TOKEN` and optionally `ML_INTERN_DEFAULT_MODEL_ID`.
 
 ## Development Checks
 

README.md

@@ -54,7 +54,7 @@ ml-intern "fine-tune llama on my dataset"
 **Options:**
 
 ```bash
-ml-intern --model anthropic/claude-sonnet-4-6:fal-ai "your prompt"
+ml-intern --model anthropic/claude-opus-4.8:fal-ai "your prompt"
 ml-intern --model moonshotai/Kimi-K2.6 "your prompt"
 ml-intern --model openai/gpt-5.5:fal-ai "your prompt"
 ml-intern --model ollama/llama3.1:8b "your prompt"
@@ -68,8 +68,9 @@ Run `ml-intern` then `/model` to see the full list of suggested model ids
 (Claude, GPT, HF Router models like MiniMax, Kimi, GLM, DeepSeek, and local
 model prefixes).
 
-In the web app, subsidized daily sessions for Claude Opus 4.8 and GPT-5.5 are
-available only to HF Pro users; Claude Sonnet 4.6 is the default premium model.
+Hosted inference is billed to the active Hugging Face user. In the web app,
+free users start on Kimi K2.6 and HF Pro users start on Claude Opus 4.8; the
+CLI default is Claude Opus 4.8.
 
 #### Local models
 
@@ -386,7 +387,7 @@ Edit `configs/cli_agent_config.json` for CLI defaults, or
 
 ```json
 {
-  "model_name": "anthropic/claude-sonnet-4-6:fal-ai",
+  "model_name": "anthropic/claude-opus-4.8:fal-ai",
   "mcpServers": {
     "your-server-name": {
       "transport": "http",

agent/context_manager/manager.py

@@ -92,7 +92,7 @@ class CompactionFailedError(Exception):
     Typically means an individual preserved message (system, first user, or
     untouched tail) exceeds what truncation can fix in one pass. The caller
     must terminate the session; retrying produces an infinite loop that burns
-    premium inference budget.
+    hosted inference budget.
     """
 
 
@@ -133,7 +133,7 @@ async def summarize_messages(
     ``session`` is optional; when provided, the call is recorded via
     ``telemetry.record_llm_call`` so its cost lands in the session's
     ``total_cost_usd``. Without it, the call still happens but is
-    invisible in telemetry, which used to hide a significant share of premium
+    invisible in telemetry, which used to hide a significant share of hosted
     inference spend.
 
     Returns ``(summary_text, completion_tokens)``.
@@ -145,7 +145,6 @@ async def summarize_messages(
         model_name,
         hf_token,
         reasoning_effort="high",
-        bill_to_user=getattr(session, "premium_user_billed", False),
     )
     llm_params = with_prompt_cache_params(
         llm_params, session_id=getattr(session, "session_id", None)
@@ -527,7 +526,7 @@ class ContextManager:
         a giant tool output stuck in the untouched tail) is too large for
         truncation to fix. The caller must terminate the session — retrying
         is what caused the 2026-05-03 infinite-compaction-loop pattern that
-        burned premium inference budget invisibly.
+        burned hosted inference budget invisibly.
         """
         if not self.needs_compaction:
             return
@@ -617,7 +616,7 @@ class ContextManager:
 
         # Hard verify: if compaction didn't bring us below the threshold even
         # after truncating oversized preserved messages, retrying just burns
-        # premium inference budget on the same useless compaction call. Raise so the
+        # hosted inference budget on the same useless compaction call. Raise so the
         # caller can terminate the session cleanly. Pre-2026-05-04, the
         # caller looped indefinitely (~$3/Opus retry) until the pod was
         # killed — invisible to the dataset because the session never

agent/core/agent_loop.py

@@ -540,7 +540,6 @@ async def _heal_effort_and_rebuild_params(
         model,
         session.hf_token,
         reasoning_effort=session.effective_effort_for(model),
-        bill_to_user=getattr(session, "premium_user_billed", False),
     )
 
 
@@ -562,8 +561,8 @@ def _friendly_error_message(error: Exception) -> str | None:
 
     if "insufficient" in err_str and "credit" in err_str:
         return (
-            "Insufficient API credits. Please check your account balance "
-            "at your model provider's dashboard."
+            "Insufficient Hugging Face Inference Providers credits. Add credits "
+            "or upgrade your HF account to continue."
         )
 
     if "not supported by provider" in err_str or "no provider supports" in err_str:
@@ -591,7 +590,7 @@ async def _compact_and_notify(session: Session) -> None:
 
     Catches ``CompactionFailedError`` and ends the session cleanly instead
     of letting the caller retry. Pre-2026-05-04 the caller looped on
-    ContextWindowExceededError → compact → re-trigger, burning premium
+    ContextWindowExceededError → compact → re-trigger, burning hosted
     inference budget while the session never reached the upload path.
     """
     from agent.context_manager.manager import CompactionFailedError
@@ -1207,7 +1206,6 @@ class Handlers:
                     reasoning_effort=session.effective_effort_for(
                         session.config.model_name
                     ),
-                    bill_to_user=getattr(session, "premium_user_billed", False),
                 )
                 if session.stream:
                     llm_result = await _call_llm_streaming(

agent/core/effort_probe.py

@@ -188,7 +188,6 @@ async def probe_effort(
                 hf_token,
                 reasoning_effort=effort,
                 strict=True,
-                bill_to_user=getattr(session, "premium_user_billed", False),
             )
         except UnsupportedEffortError:
             # Provider can't even accept this effort name (e.g. "max" on

agent/core/hf_tokens.py

@@ -41,19 +41,11 @@ def resolve_hf_router_token(session_hf_token: str | None = None) -> str | None:
     """Resolve the token used for Hugging Face Router LLM calls.
 
     App-specific precedence:
-    1. INFERENCE_TOKEN: shared hosted-Space inference token.
-    2. session_hf_token: the active user/session token.
-    3. huggingface_hub.get_token(): HF_TOKEN/HUGGING_FACE_HUB_TOKEN or
+    1. session_hf_token: the active user/session token.
+    2. huggingface_hub.get_token(): HF_TOKEN/HUGGING_FACE_HUB_TOKEN or
        local ``hf auth login`` cache.
     """
-    return resolve_hf_token(os.environ.get("INFERENCE_TOKEN"), session_hf_token)
-
-
-def get_hf_bill_to() -> str | None:
-    """Return X-HF-Bill-To only when a shared inference token is active."""
-    if clean_hf_token(os.environ.get("INFERENCE_TOKEN")):
-        return os.environ.get("HF_BILL_TO", "smolagents")
-    return None
+    return resolve_hf_token(session_hf_token)
 
 
 def bearer_token_from_header(auth_header: str | None) -> str | None:

agent/core/llm_params.py

@@ -7,11 +7,7 @@ creating circular imports.
 
 import os
 
-from agent.core.hf_tokens import (
-    get_hf_bill_to,
-    resolve_hf_router_token,
-    resolve_hf_token,
-)
+from agent.core.hf_tokens import resolve_hf_router_token
 from agent.core.local_models import (
     LOCAL_MODEL_API_KEY_DEFAULT,
     LOCAL_MODEL_API_KEY_ENV,
@@ -22,7 +18,6 @@ from agent.core.local_models import (
 )
 from agent.core.model_ids import (
     HF_ROUTER_BASE_URL,
-    is_premium_model_id,
     strip_huggingface_model_prefix,
 )
 
@@ -97,7 +92,6 @@ def _resolve_llm_params(
     session_hf_token: str | None = None,
     reasoning_effort: str | None = None,
     strict: bool = False,
-    bill_to_user: bool = False,
 ) -> dict:
     """
     Build LiteLLM kwargs for a given model id.
@@ -123,15 +117,9 @@ def _resolve_llm_params(
     can't crash a turn — it just doesn't get sent.
 
     Token precedence for HF-router calls (first non-empty wins):
-      1. INFERENCE_TOKEN env — shared key on the hosted Space (inference is
-         free for users, billed to the Space owner via ``X-HF-Bill-To``).
-      2. session.hf_token — the user's own token (CLI / OAuth / cache file).
-      3. huggingface_hub cache — ``HF_TOKEN`` / ``HUGGING_FACE_HUB_TOKEN`` /
+      1. session.hf_token — the user's own token (CLI / OAuth / cache file).
+      2. huggingface_hub cache — ``HF_TOKEN`` / ``HUGGING_FACE_HUB_TOKEN`` /
          local ``hf auth login`` cache.
-
-    Pass ``bill_to_user=True`` only after the daily subsidized allowance is
-    spent. Premium router ids then use the caller's own token, skip
-    ``INFERENCE_TOKEN``, and omit ``X-HF-Bill-To``.
     """
     normalized_model = strip_huggingface_model_prefix(model_name) or model_name
 
@@ -142,19 +130,12 @@ def _resolve_llm_params(
         return _resolve_local_model_params(normalized_model, reasoning_effort, strict)
 
     hf_model = normalized_model
-    bill_user = bill_to_user and is_premium_model_id(hf_model)
-    api_key = (
-        resolve_hf_token(session_hf_token, include_cached=False)
-        if bill_user
-        else _resolve_hf_router_token(session_hf_token)
-    )
+    api_key = _resolve_hf_router_token(session_hf_token)
     params = {
         "model": f"openai/{hf_model}",
         "api_base": HF_ROUTER_BASE_URL,
         "api_key": api_key,
     }
-    if not bill_user and (bill_to := get_hf_bill_to()):
-        params["extra_headers"] = {"X-HF-Bill-To": bill_to}
     if reasoning_effort:
         hf_level = _hf_router_effort_level(reasoning_effort)
         if hf_level not in _HF_EFFORTS:

agent/core/model_ids.py

@@ -4,27 +4,17 @@ HF_ROUTER_BASE_URL = "https://router.huggingface.co/v1"
 
 # Keep these as verbatim HF Router ids; version punctuation differs by model.
 CLAUDE_OPUS_48_MODEL_ID = "anthropic/claude-opus-4.8:fal-ai"
-CLAUDE_SONNET_46_MODEL_ID = "anthropic/claude-sonnet-4-6:fal-ai"
 GPT_55_MODEL_ID = "openai/gpt-5.5:fal-ai"
 KIMI_K26_MODEL_ID = "moonshotai/Kimi-K2.6"
 MINIMAX_M27_MODEL_ID = "MiniMaxAI/MiniMax-M2.7"
 GLM_51_MODEL_ID = "zai-org/GLM-5.1"
 DEEPSEEK_V4_PRO_MODEL_ID = "deepseek-ai/DeepSeek-V4-Pro:deepinfra"
 
-DEFAULT_MODEL_ID = CLAUDE_SONNET_46_MODEL_ID
+DEFAULT_MODEL_ID = CLAUDE_OPUS_48_MODEL_ID
 
-PREMIUM_MODEL_IDS = {
-    CLAUDE_SONNET_46_MODEL_ID,
+HOSTED_MODEL_IDS = {
     CLAUDE_OPUS_48_MODEL_ID,
     GPT_55_MODEL_ID,
-}
-
-PRO_ONLY_PREMIUM_MODEL_IDS = {
-    CLAUDE_OPUS_48_MODEL_ID,
-    GPT_55_MODEL_ID,
-}
-
-KNOWN_ROUTER_MODEL_IDS = PREMIUM_MODEL_IDS | {
     KIMI_K26_MODEL_ID,
     MINIMAX_M27_MODEL_ID,
     GLM_51_MODEL_ID,
@@ -39,16 +29,6 @@ def strip_huggingface_model_prefix(model_id: str | None) -> str | None:
     return model_id.removeprefix("huggingface/")
 
 
-def is_premium_model_id(model_id: str | None) -> bool:
-    normalized = strip_huggingface_model_prefix(model_id)
-    return bool(normalized and normalized in PREMIUM_MODEL_IDS)
-
-
-def is_pro_only_premium_model_id(model_id: str | None) -> bool:
-    normalized = strip_huggingface_model_prefix(model_id)
-    return bool(normalized and normalized in PRO_ONLY_PREMIUM_MODEL_IDS)
-
-
 def is_known_router_model_id(model_id: str | None) -> bool:
     normalized = strip_huggingface_model_prefix(model_id)
-    return bool(normalized and normalized in KNOWN_ROUTER_MODEL_IDS)
+    return bool(normalized and normalized in HOSTED_MODEL_IDS)

agent/core/model_switcher.py

@@ -28,7 +28,6 @@ from agent.core.local_models import (
 )
 from agent.core.model_ids import (
     CLAUDE_OPUS_48_MODEL_ID,
-    CLAUDE_SONNET_46_MODEL_ID,
     GPT_55_MODEL_ID,
     KIMI_K26_MODEL_ID,
     strip_huggingface_model_prefix,
@@ -40,7 +39,6 @@ from agent.core.model_ids import (
 # ":cheapest", ":preferred", or ":<provider>" to override the default routing
 # policy (auto = fastest with failover).
 SUGGESTED_MODELS = [
-    {"id": CLAUDE_SONNET_46_MODEL_ID, "label": "Claude Sonnet 4.6"},
     {"id": CLAUDE_OPUS_48_MODEL_ID, "label": "Claude Opus 4.8"},
     {"id": GPT_55_MODEL_ID, "label": "GPT-5.5"},
     {"id": "MiniMaxAI/MiniMax-M2.7", "label": "MiniMax M2.7"},

agent/core/session.py

@@ -119,11 +119,6 @@ class Session:
         self.session_id = session_id or str(uuid.uuid4())
         self.config = config
         self.is_running = True
-        # Billing mode for premium HF Router usage. The backend quota gate
-        # flips this on once the user is past their subsidized daily allowance,
-        # so the LLM call bills the user's own HF token instead of the Space.
-        # Persisted with the session so it survives idle-reclaim.
-        self.premium_user_billed: bool = False
         self.current_plan: list[dict[str, str]] = []
         self._cancelled = asyncio.Event()
         self.pending_approval: Optional[dict[str, Any]] = None

agent/core/session_persistence.py

@@ -14,7 +14,7 @@ from typing import Any
 
 from bson import BSON
 from pymongo import AsyncMongoClient, DeleteMany, ReturnDocument, UpdateOne
-from pymongo.errors import DuplicateKeyError, InvalidDocument, PyMongoError
+from pymongo.errors import InvalidDocument, PyMongoError
 
 logger = logging.getLogger(__name__)
 
@@ -89,15 +89,6 @@ class NoopSessionStore:
     async def append_trace_message(self, *_: Any, **__: Any) -> int | None:
         return None
 
-    async def get_quota(self, *_: Any, **__: Any) -> int | None:
-        return None
-
-    async def try_increment_quota(self, *_: Any, **__: Any) -> int | None:
-        return None
-
-    async def refund_quota(self, *_: Any, **__: Any) -> None:
-        return None
-
     async def mark_pro_seen(self, *_: Any, **__: Any) -> dict[str, Any] | None:
         return None
 
@@ -174,9 +165,6 @@ class MongoSessionStore(NoopSessionStore):
         message_count: int = 0,
         turn_count: int = 0,
         pending_approval: list[dict[str, Any]] | None = None,
-        claude_counted: bool = False,
-        claude_counted_day: str | None = None,
-        premium_user_billed: bool = False,
         notification_destinations: list[str] | None = None,
         auto_approval_enabled: bool = False,
         auto_approval_cost_cap_usd: float | None = None,
@@ -207,9 +195,6 @@ class MongoSessionStore(NoopSessionStore):
                     "message_count": message_count,
                     "turn_count": turn_count,
                     "pending_approval": pending_approval or [],
-                    "claude_counted": claude_counted,
-                    "claude_counted_day": claude_counted_day,
-                    "premium_user_billed": premium_user_billed,
                     "notification_destinations": notification_destinations or [],
                     "auto_approval_enabled": auto_approval_enabled,
                     "auto_approval_cost_cap_usd": auto_approval_cost_cap_usd,
@@ -231,9 +216,6 @@ class MongoSessionStore(NoopSessionStore):
         status: str = "active",
         turn_count: int = 0,
         pending_approval: list[dict[str, Any]] | None = None,
-        claude_counted: bool = False,
-        claude_counted_day: str | None = None,
-        premium_user_billed: bool = False,
         created_at: datetime | None = None,
         notification_destinations: list[str] | None = None,
         auto_approval_enabled: bool = False,
@@ -257,9 +239,6 @@ class MongoSessionStore(NoopSessionStore):
             message_count=len(messages),
             turn_count=turn_count,
             pending_approval=pending_approval,
-            claude_counted=claude_counted,
-            claude_counted_day=claude_counted_day,
-            premium_user_billed=premium_user_billed,
             notification_destinations=notification_destinations,
             auto_approval_enabled=auto_approval_enabled,
             auto_approval_cost_cap_usd=auto_approval_cost_cap_usd,
@@ -409,45 +388,6 @@ class MongoSessionStore(NoopSessionStore):
             logger.debug("Failed to append trace message for %s: %s", session_id, e)
             return None
 
-    async def get_quota(self, user_id: str, day: str) -> int | None:
-        if not self._ready():
-            return None
-        doc = await self.db.claude_quotas.find_one({"_id": f"{user_id}:{day}"})
-        return int(doc.get("count", 0)) if doc else 0
-
-    async def try_increment_quota(self, user_id: str, day: str, cap: int) -> int | None:
-        if not self._ready():
-            return None
-        key = f"{user_id}:{day}"
-        now = _now()
-        try:
-            await self.db.claude_quotas.insert_one(
-                {
-                    "_id": key,
-                    "user_id": user_id,
-                    "day": day,
-                    "count": 1,
-                    "updated_at": now,
-                }
-            )
-            return 1
-        except DuplicateKeyError:
-            pass
-        doc = await self.db.claude_quotas.find_one_and_update(
-            {"_id": key, "count": {"$lt": cap}},
-            {"$inc": {"count": 1}, "$set": {"updated_at": now}},
-            return_document=ReturnDocument.AFTER,
-        )
-        return int(doc["count"]) if doc else None
-
-    async def refund_quota(self, user_id: str, day: str) -> None:
-        if not self._ready():
-            return
-        await self.db.claude_quotas.update_one(
-            {"_id": f"{user_id}:{day}", "count": {"$gt": 0}},
-            {"$inc": {"count": -1}, "$set": {"updated_at": _now()}},
-        )
-
     async def mark_pro_seen(
         self, user_id: str, *, is_pro: bool
     ) -> dict[str, Any] | None:

agent/main.py

@@ -85,7 +85,7 @@ def _validate_cli_model_override(model: str) -> str:
     if not model_switcher.is_valid_model_id(model):
         raise ValueError(
             "Invalid model id. Use an HF Router id like "
-            "'anthropic/claude-sonnet-4-6:fal-ai' or a supported local prefix."
+            "'anthropic/claude-opus-4.8:fal-ai' or a supported local prefix."
         )
     return model.removeprefix("huggingface/")
 

agent/tools/research_tool.py

@@ -258,7 +258,6 @@ async def research_handler(
         research_model,
         getattr(session, "hf_token", None),
         reasoning_effort=_capped,
-        bill_to_user=getattr(session, "premium_user_billed", False),
     )
     llm_params = with_prompt_cache_params(
         llm_params, session_id=getattr(session, "session_id", None)

backend/dependencies.py

@@ -35,7 +35,7 @@ DEV_USER: dict[str, Any] = {
     "user_id": "dev",
     "username": "dev",
     "authenticated": True,
-    "plan": "pro",  # Dev runs at the Pro quota tier so local testing isn't capped.
+    "plan": "pro",  # Dev uses the Pro web default model.
 }
 
 INTERNAL_HF_TOKEN_KEY = "_hf_token"
@@ -137,7 +137,7 @@ def _user_from_info(user_info: dict[str, Any]) -> dict[str, Any]:
 
 
 def _normalize_user_plan(whoami: Any) -> str:
-    """Normalize a whoami-v2 payload to the app's personal quota tiers."""
+    """Normalize a whoami-v2 payload to the app's supported plan tiers."""
     if not isinstance(whoami, dict):
         return "free"
 
@@ -151,8 +151,8 @@ async def _fetch_user_plan(token: str) -> str:
     """Look up the user's HF plan via /api/whoami-v2.
 
     Returns 'free' | 'pro'. Non-200, network errors, or an unknown
-    payload shape all collapse to 'free' — safe default; we'd rather under-
-    grant the Pro cap than over-grant it on bad data.
+    payload shape all collapse to 'free' — safe default; we'd rather avoid
+    selecting the Pro default on bad data.
     """
     global _WHOAMI_SHAPE_LOGGED
     whoami = await fetch_whoami_v2(token)

backend/main.py

@@ -10,8 +10,8 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
-# Load .env before importing routes/session_manager so persistence and quota
-# modules see local Mongo settings during startup.
+# Load .env before importing routes/session_manager so persistence and model
+# modules see local settings during startup.
 load_dotenv(Path(__file__).parent.parent / ".env")
 
 from routes.agent import router as agent_router  # noqa: E402

backend/models.py

@@ -105,8 +105,6 @@ class SessionInfo(BaseModel):
     auto_approval: SessionAutoApprovalInfo = Field(
         default_factory=SessionAutoApprovalInfo
     )
-    premium_user_billed: bool = False
-    premium_quota_counted: bool = False
 
 
 class SessionNotificationsRequest(BaseModel):

backend/routes/agent.py

@@ -49,21 +49,16 @@ from session_manager import (
     session_manager,
 )
 
-import user_quotas
-
 from agent.core.hf_access import get_jobs_access
 from agent.core.hf_tokens import resolve_hf_request_token
 from agent.core.llm_params import _resolve_llm_params
 from agent.core.model_ids import (
     CLAUDE_OPUS_48_MODEL_ID,
     DEEPSEEK_V4_PRO_MODEL_ID,
-    DEFAULT_MODEL_ID,
     GLM_51_MODEL_ID,
     GPT_55_MODEL_ID,
     KIMI_K26_MODEL_ID,
     MINIMAX_M27_MODEL_ID,
-    is_premium_model_id,
-    is_pro_only_premium_model_id,
 )
 
 logger = logging.getLogger(__name__)
@@ -71,7 +66,6 @@ logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api", tags=["agent"])
 _background_teardown_tasks: set[asyncio.Task] = set()
 
-DEFAULT_PREMIUM_MODEL_ID = DEFAULT_MODEL_ID
 DEFAULT_OPUS_MODEL_ID = CLAUDE_OPUS_48_MODEL_ID
 DEFAULT_GPT_MODEL_ID = GPT_55_MODEL_ID
 DEFAULT_FREE_MODEL_ID = KIMI_K26_MODEL_ID
@@ -80,55 +74,36 @@ DATASET_UPLOAD_MULTIPART_SLACK_BYTES = 1024 * 1024
 
 def _available_models() -> list[dict[str, Any]]:
     models = [
-        {
-            "id": DEFAULT_PREMIUM_MODEL_ID,
-            "label": "Claude Sonnet 4.6",
-            "provider": "huggingface",
-            "tier": "pro",
-            "recommended": True,
-            "minimum_plan": "free",
-        },
         {
             "id": DEFAULT_OPUS_MODEL_ID,
             "label": "Claude Opus 4.8",
             "provider": "huggingface",
-            "tier": "pro",
-            "minimum_plan": "pro",
+            "recommended": True,
         },
         {
             "id": DEFAULT_GPT_MODEL_ID,
             "label": "GPT-5.5",
             "provider": "huggingface",
-            "tier": "pro",
-            "minimum_plan": "pro",
         },
         {
             "id": DEFAULT_FREE_MODEL_ID,
             "label": "Kimi K2.6",
             "provider": "huggingface",
-            "tier": "free",
-            "minimum_plan": "free",
         },
         {
             "id": MINIMAX_M27_MODEL_ID,
             "label": "MiniMax M2.7",
             "provider": "huggingface",
-            "tier": "free",
-            "minimum_plan": "free",
         },
         {
             "id": GLM_51_MODEL_ID,
             "label": "GLM 5.1",
             "provider": "huggingface",
-            "tier": "free",
-            "minimum_plan": "free",
         },
         {
             "id": DEEPSEEK_V4_PRO_MODEL_ID,
             "label": "DeepSeek V4 Pro",
             "provider": "huggingface",
-            "tier": "free",
-            "minimum_plan": "free",
         },
     ]
     return models
@@ -137,119 +112,30 @@ def _available_models() -> list[dict[str, Any]]:
 AVAILABLE_MODELS = _available_models()
 
 
-def _is_premium_model(model_id: str) -> bool:
-    return is_premium_model_id(model_id)
-
-
-def _is_pro_only_premium_model(model_id: str | None) -> bool:
-    return is_pro_only_premium_model_id(model_id)
-
-
-def _model_unavailable_for_plan(model_id: str | None, plan: str | None) -> bool:
-    return plan != "pro" and _is_pro_only_premium_model(model_id)
+def _valid_model_ids() -> set[str]:
+    return {m["id"] for m in AVAILABLE_MODELS}
 
 
-def _reject_model_unavailable_for_plan(
-    model_id: str | None,
-    user: dict[str, Any],
-) -> None:
-    plan = user.get("plan", "free")
-    if not _model_unavailable_for_plan(model_id, plan):
+def _validate_model_id(model_id: str | None) -> None:
+    if not model_id or model_id in _valid_model_ids():
         return
-    raise HTTPException(
-        status_code=403,
-        detail={
-            "error": "model_requires_pro",
-            "plan": plan,
-            "model": model_id,
-            "message": "Claude Opus 4.8 and GPT-5.5 daily sessions require HF Pro.",
-        },
-    )
+    raise HTTPException(status_code=400, detail=f"Unknown model: {model_id}")
 
 
-def _is_user_billed(model_id: str) -> bool:
-    return _is_premium_model(model_id)
+def _default_model_for_user(user: dict[str, Any]) -> str:
+    return DEFAULT_OPUS_MODEL_ID if user.get("plan") == "pro" else DEFAULT_FREE_MODEL_ID
 
 
 async def _model_override_for_new_session(
-    request: Request,
     requested_model: str | None,
+    user: dict[str, Any],
 ) -> str | None:
     """Return the model override to use when creating a new session.
 
-    Explicit model requests are allowed and charged at message-submit time
-    when premium. Empty requests use the configured default model.
-    """
-    return requested_model
-
-
-def _premium_cap_message(plan: str) -> str:
-    """Over-allowance message for a premium model that can't fall back to user
-    billing. Defensive: every current premium model is user-billable and
-    overflows to the user's own HF account instead of reaching this.
-    """
-    if plan == "pro":
-        return (
-            "Daily premium model limit reached. Use a free model and try premium "
-            "models again tomorrow."
-        )
-    return (
-        "Daily premium model limit reached. Upgrade to HF Pro for "
-        f"{user_quotas.CLAUDE_PRO_DAILY}/day or use a free model."
-    )
-
-
-async def _enforce_premium_model_quota(
-    user: dict[str, Any],
-    agent_session: AgentSession,
-) -> None:
-    """Charge the user's daily premium-model quota on first use in a session.
-
-    Runs at *message-submit* time, not session-create time — so spinning up a
-    premium-model session to look around doesn't burn quota. The
-    ``claude_counted_day`` flag on ``AgentSession`` guards against re-counting
-    the same session on the same day, while still counting old sessions when
-    they are used again on a later day.
-
-    Subsidizes the daily allowance (free = 2 for default premium, pro = 20
-    across premium models), organization-billed through the HF Router. Opus and
-    GPT-5.5 are pro-only before quota is charged. Past the allowance, premium
-    router models flip the session to ``premium_user_billed`` so the call bills
-    the user's own HF token instead of blocking. No-ops when the model isn't
-    premium or when this session's billing has already been decided for today.
+    Explicit model requests are honored. Empty web requests default to Kimi for
+    non-Pro users and Opus for Pro users.
     """
-    model_name = agent_session.session.config.model_name
-    if not _is_premium_model(model_name):
-        return
-    _reject_model_unavailable_for_plan(model_name, user)
-    quota_day = user_quotas.current_quota_day()
-    if agent_session.claude_counted and agent_session.claude_counted_day == quota_day:
-        return
-    user_id = user["user_id"]
-    plan = user.get("plan", "free")
-    cap = user_quotas.daily_cap_for(plan)
-    within_allowance = await user_quotas.try_increment_claude(user_id, cap) is not None
-    if not within_allowance:
-        if not _is_user_billed(model_name):
-            raise HTTPException(
-                status_code=429,
-                detail={
-                    "error": "premium_model_daily_cap",
-                    "plan": plan,
-                    "cap": cap,
-                    "message": _premium_cap_message(plan),
-                },
-            )
-        # Past the subsidized allowance on a user-billable model: bill the
-        # user's own HF (OAuth) token for this session instead of blocking.
-        agent_session.session.premium_user_billed = True
-    else:
-        # A session that overflowed on a previous day can use today's
-        # subsidized allowance again if quota is available.
-        agent_session.session.premium_user_billed = False
-    agent_session.claude_counted = True
-    agent_session.claude_counted_day = quota_day
-    await session_manager.persist_session_snapshot(agent_session)
+    return requested_model or _default_model_for_user(user)
 
 
 def _user_hf_token(user: dict[str, Any] | None) -> str | None:
@@ -494,8 +380,7 @@ async def create_session(
     behalf of the user.
 
     Optional body ``{"model"?: <id>}`` selects the session's LLM; unknown
-    ids are rejected (400). The premium-model quota runs at message-submit
-    time, not here — spinning up a session to look around is free.
+    ids are rejected (400). Empty requests use the plan-aware web default.
 
     Returns 503 if the server or user has reached the session limit.
     """
@@ -511,13 +396,10 @@ async def create_session(
     if isinstance(body, dict):
         model = body.get("model")
 
-    valid_ids = {m["id"] for m in AVAILABLE_MODELS}
-    if model and model not in valid_ids:
-        raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
-    _reject_model_unavailable_for_plan(model, user)
+    _validate_model_id(model)
 
-    # Empty requests use the configured default, which may be premium.
-    model = await _model_override_for_new_session(request, model)
+    # Empty requests use the plan-aware web default.
+    model = await _model_override_for_new_session(model, user)
 
     try:
         session_id = await session_manager.create_session(
@@ -533,7 +415,7 @@ async def create_session(
     return SessionResponse(
         session_id=session_id,
         ready=True,
-        model=model or session_manager.config.model_name,
+        model=model,
     )
 
 
@@ -546,9 +428,8 @@ async def restore_session_summary(
     summarization prompt on them and drop the result into the new
     session's context as a user-role system note.
 
-    Optional ``"model"`` in the body overrides the session's LLM. The
-    premium-model quota runs before summarization because that call uses the
-    session model immediately.
+    Optional ``"model"`` in the body overrides the session's LLM; otherwise
+    the new session uses the plan-aware web default.
     """
     messages = body.get("messages")
     if not isinstance(messages, list) or not messages:
@@ -557,12 +438,9 @@ async def restore_session_summary(
     hf_token = resolve_hf_request_token(request)
 
     model = body.get("model")
-    valid_ids = {m["id"] for m in AVAILABLE_MODELS}
-    if model and model not in valid_ids:
-        raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
-    _reject_model_unavailable_for_plan(model, user)
+    _validate_model_id(model)
 
-    model = await _model_override_for_new_session(request, model)
+    model = await _model_override_for_new_session(model, user)
 
     try:
         session_id = await session_manager.create_session(
@@ -575,14 +453,12 @@ async def restore_session_summary(
     except SessionCapacityError as e:
         raise HTTPException(status_code=503, detail=str(e))
 
-    agent_session = await _check_session_access(
+    await _check_session_access(
         session_id,
         user,
         request,
         preload_sandbox=False,
     )
-    await _enforce_premium_model_quota(user, agent_session)
-
     try:
         summarized = await session_manager.seed_from_summary(session_id, messages)
     except ValueError as e:
@@ -598,7 +474,7 @@ async def restore_session_summary(
     return SessionResponse(
         session_id=session_id,
         ready=True,
-        model=model or session_manager.config.model_name,
+        model=model,
     )
 
 
@@ -622,17 +498,13 @@ async def set_session_model(
     """Switch the active model for a single session (tab-scoped).
 
     Takes effect on the next LLM call in that session — other sessions
-    (including other browser tabs) are unaffected. Model switches don't
-    charge quota — the premium-model quota only fires at message-submit time.
+    (including other browser tabs) are unaffected.
     """
     agent_session = await _check_session_access(session_id, user, request)
     model_id = body.get("model")
     if not model_id:
         raise HTTPException(status_code=400, detail="Missing 'model' field")
-    valid_ids = {m["id"] for m in AVAILABLE_MODELS}
-    if model_id not in valid_ids:
-        raise HTTPException(status_code=400, detail=f"Unknown model: {model_id}")
-    _reject_model_unavailable_for_plan(model_id, user)
+    _validate_model_id(model_id)
     if not agent_session:
         raise HTTPException(status_code=404, detail="Session not found")
     await session_manager.update_session_model(session_id, model_id)
@@ -765,21 +637,6 @@ async def set_session_yolo(
     return {"session_id": session_id, **summary}
 
 
-@router.get("/user/quota")
-async def get_user_quota(user: dict = Depends(get_current_user)) -> dict:
-    """Return the user's plan tier and today's premium-model quota state."""
-    plan = user.get("plan", "free")
-    used = await user_quotas.get_claude_used_today(user["user_id"])
-    cap = user_quotas.daily_cap_for(plan)
-    remaining = max(0, cap - used)
-    return {
-        "plan": plan,
-        "premium_used_today": used,
-        "premium_daily_cap": cap,
-        "premium_remaining": remaining,
-    }
-
-
 @router.get("/user/jobs-access")
 async def get_jobs_access_info(
     request: Request, user: dict = Depends(get_current_user)
@@ -858,12 +715,11 @@ async def submit_input(
                 }
             ]
         )
-    agent_session = await _check_session_access(raw_session_id, user)
+    await _check_session_access(raw_session_id, user)
     try:
         body = SubmitRequest(**payload)
     except ValidationError as exc:
         raise RequestValidationError(exc.errors()) from exc
-    await _enforce_premium_model_quota(user, agent_session)
     success = await session_manager.submit_user_input(body.session_id, body.text)
     if not success:
         raise HTTPException(status_code=404, detail="Session not found or inactive")
@@ -915,16 +771,6 @@ async def chat_sse(
     text = body.get("text")
     approvals = body.get("approvals")
 
-    # Gate user-message sends against the daily premium-model quota. Approvals are
-    # continuations of an in-progress turn, so the relevant quota decision was
-    # made when that user message was submitted.
-    if text is not None and not approvals:
-        try:
-            await _enforce_premium_model_quota(user, agent_session)
-        except HTTPException:
-            broadcaster.unsubscribe(sub_id)
-            raise
-
     try:
         if approvals:
             formatted = [

backend/session_manager.py

@@ -6,14 +6,13 @@ import logging
 import os
 import uuid
 from dataclasses import dataclass, field
-from datetime import UTC, datetime, timedelta
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Optional
 
 from agent.config import load_config
 from agent.core.agent_loop import process_submission
 from agent.core.model_ids import (
-    DEFAULT_MODEL_ID,
     KIMI_K26_MODEL_ID,
     is_known_router_model_id,
     strip_huggingface_model_prefix,
@@ -113,28 +112,6 @@ class AgentSession:
     is_reaping: bool = False
     broadcaster: Any = None
     title: str | None = None
-    # True once this session has ever been counted against premium quota.
-    # claude_counted_day decides whether it has already consumed today's cap.
-    claude_counted: bool = False
-    claude_counted_day: str | None = None
-
-
-def _quota_day_today() -> str:
-    return datetime.now(UTC).date().isoformat()
-
-
-def _quota_counted_today(agent_session: AgentSession) -> bool:
-    return (
-        agent_session.claude_counted
-        and agent_session.claude_counted_day == _quota_day_today()
-    )
-
-
-def _premium_user_billed_today(agent_session: AgentSession) -> bool:
-    return bool(
-        getattr(agent_session.session, "premium_user_billed", False)
-        and _quota_counted_today(agent_session)
-    )
 
 
 class SessionCapacityError(Exception):
@@ -231,23 +208,18 @@ class SessionManager:
     @staticmethod
     def _model_from_saved_metadata(
         model: str | None,
-        *,
-        premium_user_billed: bool,
-        claude_counted: bool,
-    ) -> tuple[str, bool, bool]:
+    ) -> str:
         normalized = strip_huggingface_model_prefix(model)
         if normalized and is_known_router_model_id(normalized):
-            return normalized, premium_user_billed, claude_counted
+            return normalized
 
-        fallback_model = KIMI_K26_MODEL_ID if premium_user_billed else DEFAULT_MODEL_ID
+        fallback_model = KIMI_K26_MODEL_ID
         logger.warning(
             "Saved session model %r failed validation; using %r",
             model,
             fallback_model,
         )
-        if fallback_model == KIMI_K26_MODEL_ID:
-            return fallback_model, False, False
-        return fallback_model, premium_user_billed, claude_counted
+        return fallback_model
 
     def _create_session_sync(
         self,
@@ -618,11 +590,6 @@ class SessionManager:
                 pending_approval=self._serialize_pending_approval(
                     agent_session.session
                 ),
-                claude_counted=agent_session.claude_counted,
-                claude_counted_day=agent_session.claude_counted_day,
-                premium_user_billed=getattr(
-                    agent_session.session, "premium_user_billed", False
-                ),
                 created_at=agent_session.created_at,
                 notification_destinations=list(
                     agent_session.session.notification_destinations
@@ -711,18 +678,9 @@ class SessionManager:
 
         from litellm import Message
 
-        model, premium_user_billed, claude_counted = self._model_from_saved_metadata(
+        model = self._model_from_saved_metadata(
             meta.get("model") or self.config.model_name,
-            premium_user_billed=bool(meta.get("premium_user_billed", False)),
-            claude_counted=bool(meta.get("claude_counted")),
         )
-        claude_counted_day = (
-            str(meta.get("claude_counted_day"))
-            if meta.get("claude_counted_day")
-            else None
-        )
-        if not claude_counted:
-            claude_counted_day = None
         event_queue: asyncio.Queue = asyncio.Queue()
         submission_queue: asyncio.Queue = asyncio.Queue()
         tool_router, session = await asyncio.to_thread(
@@ -781,7 +739,6 @@ class SessionManager:
         self._restore_pending_approval(session, meta.get("pending_approval") or [])
         session.turn_count = int(meta.get("turn_count") or 0)
         session.auto_approval_enabled = bool(meta.get("auto_approval_enabled", False))
-        session.premium_user_billed = premium_user_billed
         raw_cap = meta.get("auto_approval_cost_cap_usd")
         session.auto_approval_cost_cap_usd = (
             float(raw_cap) if isinstance(raw_cap, int | float) else None
@@ -805,8 +762,6 @@ class SessionManager:
             created_at=created_at,
             is_active=True,
             is_processing=False,
-            claude_counted=claude_counted,
-            claude_counted_day=claude_counted_day,
             title=meta.get("title"),
         )
         started = await self._start_agent_session(
@@ -1533,8 +1488,6 @@ class SessionManager:
                 agent_session.session.notification_destinations
             ),
             "auto_approval": self._auto_approval_summary(agent_session.session),
-            "premium_user_billed": _premium_user_billed_today(agent_session),
-            "premium_quota_counted": _quota_counted_today(agent_session),
         }
 
     def set_notification_destinations(
@@ -1588,10 +1541,6 @@ class SessionManager:
                 else:
                     created_at_str = str(created_at or datetime.utcnow().isoformat())
                 pending = self._pending_docs_for_api(row.get("pending_approval") or [])
-                quota_counted_today = (
-                    bool(row.get("claude_counted", False))
-                    and row.get("claude_counted_day") == _quota_day_today()
-                )
                 results.append(
                     {
                         "session_id": str(sid),
@@ -1603,11 +1552,6 @@ class SessionManager:
                         "pending_approval": pending or None,
                         "model": row.get("model"),
                         "title": row.get("title"),
-                        "premium_user_billed": bool(
-                            row.get("premium_user_billed", False)
-                            and quota_counted_today
-                        ),
-                        "premium_quota_counted": quota_counted_today,
                         "notification_destinations": row.get(
                             "notification_destinations"
                         )

backend/user_quotas.py

@@ -1,135 +0,0 @@
-"""Daily quota for subsidized premium model sessions.
-
-Tracks per-user premium model session starts against a daily cap derived from
-the user's HF plan. MongoDB is the source of truth when configured; the
-in-process dict remains the fallback for local/dev/test runs.
-
-The public names still say ``claude`` because this quota bucket originally
-only covered Claude and the persisted session field uses that name.
-
-Unit: first premium-model submit per session per UTC day, not raw messages. A
-user who sends with an allowed premium model in any session consumes one quota
-point for that day; continuing the same session on the same day doesn't
-(`AgentSession.claude_counted_day` guards that). Model-level plan gates live in
-``backend.routes.agent``; this module only tracks the per-plan daily cap.
-
-Cap tiers:
-  free user   → CLAUDE_FREE_DAILY (2) for the default premium model
-  pro user    → CLAUDE_PRO_DAILY  (20)
-"""
-
-import asyncio
-import os
-from datetime import UTC, datetime
-
-from agent.core.session_persistence import (
-    NoopSessionStore,
-    get_session_store,
-    _reset_store_for_tests,
-)
-
-CLAUDE_FREE_DAILY: int = int(os.environ.get("CLAUDE_FREE_DAILY", "2"))
-CLAUDE_PRO_DAILY: int = int(os.environ.get("CLAUDE_PRO_DAILY", "20"))
-
-# user_id -> (day_utc_iso, count_for_that_day)
-_claude_counts: dict[str, tuple[str, int]] = {}
-_lock = asyncio.Lock()
-
-
-def _today() -> str:
-    return datetime.now(UTC).date().isoformat()
-
-
-def current_quota_day() -> str:
-    """Return the UTC date key used for today's premium-model quota bucket."""
-    return _today()
-
-
-def daily_cap_for(plan: str | None) -> int:
-    """Return the daily Claude-session cap for the given plan."""
-    return CLAUDE_PRO_DAILY if plan == "pro" else CLAUDE_FREE_DAILY
-
-
-async def get_claude_used_today(user_id: str) -> int:
-    """Return today's Claude session count for the user (0 if none / stale day)."""
-    store = get_session_store()
-    if getattr(store, "enabled", False):
-        db_count = await store.get_quota(user_id, _today())
-        return db_count or 0
-
-    async with _lock:
-        entry = _claude_counts.get(user_id)
-        if entry is None:
-            return 0
-        day, count = entry
-        if day != _today():
-            # Stale day — drop the entry so the first increment starts fresh.
-            _claude_counts.pop(user_id, None)
-            return 0
-        return count
-
-
-async def increment_claude(user_id: str) -> int:
-    """Bump today's Claude session count for the user. Returns the new value."""
-    store = get_session_store()
-    if getattr(store, "enabled", False):
-        db_count = await store.try_increment_quota(user_id, _today(), cap=10**9)
-        return db_count or 0
-
-    async with _lock:
-        today = _today()
-        day, count = _claude_counts.get(user_id, (today, 0))
-        if day != today:
-            count = 0
-        count += 1
-        _claude_counts[user_id] = (today, count)
-        return count
-
-
-async def try_increment_claude(user_id: str, cap: int) -> int | None:
-    """Atomically bump today's count if below *cap*.
-
-    Returns the new count, or None when the user is already at the cap.
-    """
-    store = get_session_store()
-    if getattr(store, "enabled", False):
-        return await store.try_increment_quota(user_id, _today(), cap)
-
-    async with _lock:
-        today = _today()
-        day, count = _claude_counts.get(user_id, (today, 0))
-        if day != today:
-            count = 0
-        if count >= cap:
-            return None
-        count += 1
-        _claude_counts[user_id] = (today, count)
-        return count
-
-
-async def refund_claude(user_id: str) -> None:
-    """Decrement today's count — used when session creation fails after a successful gate."""
-    store = get_session_store()
-    if getattr(store, "enabled", False):
-        await store.refund_quota(user_id, _today())
-        return
-
-    async with _lock:
-        entry = _claude_counts.get(user_id)
-        if entry is None:
-            return
-        day, count = entry
-        if day != _today():
-            _claude_counts.pop(user_id, None)
-            return
-        new_count = max(0, count - 1)
-        if new_count == 0:
-            _claude_counts.pop(user_id, None)
-        else:
-            _claude_counts[user_id] = (day, new_count)
-
-
-def _reset_for_tests() -> None:
-    """Test-only: clear the in-memory store."""
-    _claude_counts.clear()
-    _reset_store_for_tests(NoopSessionStore())

configs/cli_agent_config.json

@@ -1,5 +1,5 @@
 {
-  "model_name": "anthropic/claude-sonnet-4-6:fal-ai",
+  "model_name": "anthropic/claude-opus-4.8:fal-ai",
   "save_sessions": true,
   "session_dataset_repo": "smolagents/ml-intern-sessions",
   "share_traces": true,

configs/frontend_agent_config.json

@@ -1,5 +1,5 @@
 {
-  "model_name": "${ML_INTERN_DEFAULT_MODEL_ID:-anthropic/claude-sonnet-4-6:fal-ai}",
+  "model_name": "${ML_INTERN_DEFAULT_MODEL_ID:-moonshotai/Kimi-K2.6}",
   "save_sessions": true,
   "session_dataset_repo": "smolagents/ml-intern-sessions",
   "share_traces": true,

frontend/src/components/Chat/BillingBanner.tsx

@@ -1,81 +0,0 @@
-/**
- * Shown above the composer when the active session's premium usage is being
- * billed to the user's own HF account — i.e. they're past the subsidized daily
- * allowance and the session flipped to `premium_user_billed`. Dismissible once
- * per day so we stay transparent about billing without nagging every session.
- */
-import { useState } from 'react';
-import { Box, Link, Typography } from '@mui/material';
-
-const DISMISS_KEY = 'ml-intern:billing-banner-dismissed';
-const today = () => new Date().toISOString().slice(0, 10);
-
-export default function BillingBanner() {
-  const [dismissed, setDismissed] = useState(() => {
-    try {
-      return localStorage.getItem(DISMISS_KEY) === today();
-    } catch {
-      return false;
-    }
-  });
-
-  if (dismissed) return null;
-
-  const dismiss = () => {
-    try {
-      localStorage.setItem(DISMISS_KEY, today());
-    } catch {
-      /* ignore storage failures */
-    }
-    setDismissed(true);
-  };
-
-  return (
-    <Box sx={{ maxWidth: '880px', mx: 'auto', width: '100%', px: { xs: 0, sm: 1, md: 2 }, mb: 1 }}>
-      <Box
-        sx={{
-          display: 'flex',
-          alignItems: 'center',
-          gap: 1.5,
-          p: '8px 12px',
-          borderRadius: 'var(--radius-md)',
-          bgcolor: 'var(--accent-yellow-weak)',
-          border: '1px solid var(--border)',
-        }}
-      >
-        <Typography
-          variant="caption"
-          sx={{ flex: 1, color: 'var(--text)', fontSize: '0.78rem', lineHeight: 1.5 }}
-        >
-          You've used today's subsidized premium sessions — this session's usage is billed to your{' '}
-          <Link
-            href="https://huggingface.co/settings/billing"
-            target="_blank"
-            rel="noopener noreferrer"
-            sx={{ color: 'inherit', textDecoration: 'underline' }}
-          >
-            Hugging Face account
-          </Link>{' '}
-          through Hugging Face Inference Providers.
-        </Typography>
-        <Box
-          component="button"
-          onClick={dismiss}
-          aria-label="Dismiss billing notice"
-          sx={{
-            border: 'none',
-            background: 'none',
-            cursor: 'pointer',
-            color: 'var(--muted-text)',
-            fontSize: '0.95rem',
-            lineHeight: 1,
-            p: 0.5,
-            '&:hover': { color: 'var(--text)' },
-          }}
-        >
-          ✕
-        </Box>
-      </Box>
-    </Box>
-  );
-}

frontend/src/components/Chat/ChatErrorBanner.tsx

@@ -1,5 +1,8 @@
 import { useEffect, useMemo, useState } from 'react';
-import { Alert, AlertTitle, Box, Button, Typography } from '@mui/material';
+import { Alert, AlertTitle, Box, Button, Link, Typography } from '@mui/material';
+import { useAgentStore } from '@/store/agentStore';
+import { apiFetch } from '@/utils/api';
+import { inferenceCreditCta, isInferenceCreditError } from '@/utils/inferenceBilling';
 
 interface ChatErrorBannerProps {
   error: string;
@@ -8,9 +11,14 @@ interface ChatErrorBannerProps {
   onDismiss: () => void;
 }
 
+const DISCUSSIONS_URL = 'https://huggingface.co/spaces/smolagents/ml-intern/discussions';
+
 export default function ChatErrorBanner({ error, sessionId, model, onDismiss }: ChatErrorBannerProps) {
   const [copied, setCopied] = useState(false);
   const [reportedAt, setReportedAt] = useState(() => new Date().toISOString());
+  const userPlan = useAgentStore((s) => s.user?.plan);
+  const isCreditError = isInferenceCreditError(error);
+  const creditCta = isCreditError ? inferenceCreditCta(userPlan) : null;
 
   useEffect(() => {
     setReportedAt(new Date().toISOString());
@@ -37,6 +45,14 @@ export default function ChatErrorBanner({ error, sessionId, model, onDismiss }:
     }
   };
 
+  const trackProClick = () => {
+    if (userPlan === 'pro') return;
+    void apiFetch(`/api/pro-click/${sessionId}`, {
+      method: 'POST',
+      body: JSON.stringify({ source: 'inference_credit_error', target: 'hf_pro' }),
+    }).catch(() => {});
+  };
+
   return (
     <Box sx={{ maxWidth: 880, mx: 'auto', width: '100%', px: { xs: 0, sm: 1, md: 2 }, mb: 1 }}>
       <Alert
@@ -61,12 +77,58 @@ export default function ChatErrorBanner({ error, sessionId, model, onDismiss }:
         }
       >
         <AlertTitle sx={{ fontWeight: 700, fontSize: '0.86rem' }}>
-          Message failed
+          {creditCta?.title ?? 'Message failed'}
         </AlertTitle>
         <Typography variant="body2" sx={{ fontSize: '0.8rem', lineHeight: 1.5 }}>
-          The backend could not process the last message. Retry after a moment. If it keeps
-          happening, raise an issue with the copied details.
+          {creditCta ? (
+            creditCta.message
+          ) : (
+            <>
+              The backend could not process the last message. Retry after a moment. If it keeps
+              happening,{' '}
+              <Link
+                href={DISCUSSIONS_URL}
+                target="_blank"
+                rel="noopener noreferrer"
+                color="inherit"
+                underline="always"
+              >
+                open a discussion
+              </Link>{' '}
+              with the copied details.
+            </>
+          )}
         </Typography>
+        {creditCta && (
+          <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.75, mt: 1 }}>
+            <Button
+              component="a"
+              href={creditCta.primaryHref}
+              target="_blank"
+              rel="noopener noreferrer"
+              color="inherit"
+              size="small"
+              variant="outlined"
+              onClick={trackProClick}
+              sx={{ textTransform: 'none' }}
+            >
+              {creditCta.primaryLabel}
+            </Button>
+            {creditCta.secondaryHref && creditCta.secondaryLabel && (
+              <Button
+                component="a"
+                href={creditCta.secondaryHref}
+                target="_blank"
+                rel="noopener noreferrer"
+                color="inherit"
+                size="small"
+                sx={{ textTransform: 'none' }}
+              >
+                {creditCta.secondaryLabel}
+              </Button>
+            )}
+          </Box>
+        )}
         <Typography
           variant="caption"
           component="pre"

frontend/src/components/Chat/ChatInput.tsx

@@ -20,28 +20,23 @@ import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
 import StopIcon from '@mui/icons-material/Stop';
 import AddIcon from '@mui/icons-material/Add';
 import { apiFetch, apiUpload } from '@/utils/api';
-import type { PlanTier, UserQuota } from '@/hooks/useUserQuota';
 import JobsUpgradeDialog from '@/components/JobsUpgradeDialog';
 import { useAgentStore } from '@/store/agentStore';
 import { useSessionStore } from '@/store/sessionStore';
 import {
-  CLAUDE_MODEL_PATH,
   CLAUDE_OPUS_48_MODEL_PATH,
   GPT_55_MODEL_PATH,
+  KIMI_K26_MODEL_PATH,
   isClaudePath,
-  isPremiumPath,
-  isProOnlyPath,
 } from '@/utils/model';
 
 // Model configuration
 interface ModelOption {
   id: string;
   name: string;
-  description: string;
   modelPath: string;
   avatarUrl: string;
   recommended?: boolean;
-  minimumPlan?: 'free' | 'pro';
 }
 
 const getHfAvatarUrl = (modelId: string) => {
@@ -50,66 +45,52 @@ const getHfAvatarUrl = (modelId: string) => {
 };
 
 const DEFAULT_MODEL_OPTIONS: ModelOption[] = [
-  {
-    id: 'claude-sonnet-4-6',
-    name: 'Claude Sonnet 4.6',
-    description: 'Hugging Face',
-    modelPath: CLAUDE_MODEL_PATH,
-    avatarUrl: getHfAvatarUrl(CLAUDE_MODEL_PATH),
-    recommended: true,
-  },
   {
     id: 'claude-opus-4-8',
     name: 'Claude Opus 4.8',
-    description: 'Hugging Face',
     modelPath: CLAUDE_OPUS_48_MODEL_PATH,
     avatarUrl: getHfAvatarUrl(CLAUDE_OPUS_48_MODEL_PATH),
-    minimumPlan: 'pro',
+    recommended: true,
   },
   {
     id: 'gpt-5.5',
     name: 'GPT-5.5',
-    description: 'Hugging Face',
     modelPath: GPT_55_MODEL_PATH,
     avatarUrl: getHfAvatarUrl(GPT_55_MODEL_PATH),
-    minimumPlan: 'pro',
   },
   {
     id: 'kimi-k2.6',
     name: 'Kimi K2.6',
-    description: 'Hugging Face',
-    modelPath: 'moonshotai/Kimi-K2.6',
-    avatarUrl: getHfAvatarUrl('moonshotai/Kimi-K2.6'),
+    modelPath: KIMI_K26_MODEL_PATH,
+    avatarUrl: getHfAvatarUrl(KIMI_K26_MODEL_PATH),
   },
   {
     id: 'minimax-m2.7',
     name: 'MiniMax M2.7',
-    description: 'Hugging Face',
     modelPath: 'MiniMaxAI/MiniMax-M2.7',
     avatarUrl: getHfAvatarUrl('MiniMaxAI/MiniMax-M2.7'),
   },
   {
     id: 'glm-5.1',
     name: 'GLM 5.1',
-    description: 'Hugging Face',
     modelPath: 'zai-org/GLM-5.1',
     avatarUrl: getHfAvatarUrl('zai-org/GLM-5.1'),
   },
   {
     id: 'deepseek-v4-pro',
     name: 'DeepSeek V4 Pro',
-    description: 'Hugging Face',
     modelPath: 'deepseek-ai/DeepSeek-V4-Pro:deepinfra',
     avatarUrl: getHfAvatarUrl('deepseek-ai/DeepSeek-V4-Pro'),
   },
 ];
 
+const DEFAULT_FREE_MODEL_OPTION_ID = 'kimi-k2.6';
+
 const normalizeModelPath = (path: string | undefined) => (
   (path ?? '')
     .toLowerCase()
     .replace(/^huggingface\//, '')
     .replace(/claude-opus-4\.(\d)/g, 'claude-opus-4-$1')
-    .replace(/claude-sonnet-4\.(\d)/g, 'claude-sonnet-4-$1')
 );
 
 const findModelByPath = (path: string, options: ModelOption[]): ModelOption | undefined => {
@@ -142,17 +123,14 @@ const modelOptionFromApi = (model: {
   label?: string;
   provider?: string;
   recommended?: boolean;
-  minimum_plan?: string;
 }): ModelOption | null => {
   if (!model.id) return null;
   return {
     id: modelOptionId(model.id),
     name: model.label ?? model.id,
-    description: 'Hugging Face',
     modelPath: model.id,
     avatarUrl: getHfAvatarUrl(model.id.replace(/^huggingface\//, '')),
     recommended: Boolean(model.recommended),
-    minimumPlan: model.minimum_plan === 'pro' ? 'pro' : 'free',
   };
 };
 
@@ -178,8 +156,6 @@ interface ChatInputProps {
   isProcessing?: boolean;
   disabled?: boolean;
   placeholder?: string;
-  quota: UserQuota | null;
-  refreshQuota: () => Promise<void> | void;
 }
 
 interface DatasetUploadResponse {
@@ -202,13 +178,6 @@ const DATASET_UPLOAD_ACCEPT = '.csv,.json,.jsonl';
 const DATASET_UPLOAD_EXTENSIONS = new Set(['csv', 'json', 'jsonl']);
 
 const isClaudeModel = (m: ModelOption) => isClaudePath(m.modelPath);
-const isPremiumModel = (m: ModelOption) => isPremiumPath(m.modelPath);
-const isProOnlyModel = (m: ModelOption) => (
-  m.minimumPlan === 'pro' || isProOnlyPath(m.modelPath)
-);
-const isModelAllowedForPlan = (m: ModelOption, plan: PlanTier) => (
-  plan === 'pro' || !isProOnlyModel(m)
-);
 
 const formatBytes = (bytes: number) => {
   if (bytes < 1024) return `${bytes} B`;
@@ -220,7 +189,7 @@ const datasetRepoUrl = (repoId: string) => (
   `https://huggingface.co/datasets/${repoId.split('/').map(encodeURIComponent).join('/')}`
 );
 
-export default function ChatInput({ sessionId, initialModelPath, onSend, onStop, onDatasetUploaded, isProcessing = false, disabled = false, placeholder = 'Ask anything...', quota, refreshQuota }: ChatInputProps) {
+export default function ChatInput({ sessionId, initialModelPath, onSend, onStop, onDatasetUploaded, isProcessing = false, disabled = false, placeholder = 'Ask anything...' }: ChatInputProps) {
   const [input, setInput] = useState('');
   const inputRef = useRef<HTMLTextAreaElement>(null);
   const fileInputRef = useRef<HTMLInputElement>(null);
@@ -228,7 +197,10 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
   const modelOptionsRef = useRef<ModelOption[]>(DEFAULT_MODEL_OPTIONS);
   const sessionIdRef = useRef<string | undefined>(sessionId);
   const [selectedModelId, setSelectedModelId] = useState<string>(
-    () => findModelByPath(initialModelPath ?? '', DEFAULT_MODEL_OPTIONS)?.id ?? DEFAULT_MODEL_OPTIONS[0].id,
+    () => (
+      findModelByPath(initialModelPath ?? '', DEFAULT_MODEL_OPTIONS)?.id
+      ?? DEFAULT_FREE_MODEL_OPTION_ID
+    ),
   );
   const [modelAnchorEl, setModelAnchorEl] = useState<null | HTMLElement>(null);
   const jobsUpgradeRequired = useAgentStore((s) => s.jobsUpgradeRequired);
@@ -290,10 +262,7 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
     return () => { cancelled = true; };
   }, [sessionId, updateSessionModel]);
 
-  const plan = quota?.plan ?? 'free';
-  const visibleModelOptions = modelOptions.filter((model) => (
-    isModelAllowedForPlan(model, plan)
-  ));
+  const visibleModelOptions = modelOptions;
   const selectedModel = (
     visibleModelOptions.find(m => m.id === selectedModelId)
     || modelOptions.find(m => m.id === selectedModelId)
@@ -309,16 +278,11 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
   }, [disabled, isProcessing]);
 
   const handleSend = useCallback(() => {
-    const selectedOption = modelOptions.find((model) => model.id === selectedModelId);
-    if (selectedOption && !isModelAllowedForPlan(selectedOption, plan)) {
-      setModelSwitchError('Claude Opus 4.8 and GPT-5.5 daily sessions require HF Pro.');
-      return;
-    }
     if (input.trim() && !disabled && !isUploadingDataset) {
       onSend(input);
       setInput('');
     }
-  }, [input, disabled, isUploadingDataset, onSend, modelOptions, selectedModelId, plan]);
+  }, [input, disabled, isUploadingDataset, onSend]);
 
   const handleDatasetUploadClick = useCallback(() => {
     fileInputRef.current?.click();
@@ -395,13 +359,6 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
     return () => window.clearTimeout(timeout);
   }, [datasetUploadSuccess]);
 
-  // Refresh the quota display whenever the session changes (user might
-  // have started another tab that spent quota).
-  useEffect(() => {
-    if (sessionId) refreshQuota();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [sessionId]);
-
   const handleKeyDown = useCallback(
     (e: KeyboardEvent<HTMLDivElement>) => {
       if (e.key === 'Enter' && !e.shiftKey) {
@@ -414,7 +371,6 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
 
   const handleModelClick = (event: React.MouseEvent<HTMLElement>) => {
     setModelAnchorEl(event.currentTarget);
-    void refreshQuota();
   };
 
   const handleModelClose = () => {
@@ -424,10 +380,6 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
   const handleSelectModel = async (model: ModelOption) => {
     handleModelClose();
     if (!sessionId) return;
-    if (!isModelAllowedForPlan(model, plan)) {
-      setModelSwitchError('Claude Opus 4.8 and GPT-5.5 daily sessions require HF Pro.');
-      return;
-    }
     try {
       const res = await apiFetch(`/api/session/${sessionId}/model`, {
         method: 'POST',
@@ -486,16 +438,6 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
     return () => document.removeEventListener('visibilitychange', onVisible);
   }, [awaitingTopUp, jobsUpgradeRequired, handleJobsRetry]);
 
-  // Show the remaining subsidized premium-session allowance for today.
-  const premiumChip = (() => {
-    if (!quota) return null;
-    const remaining = Math.max(0, quota.premiumRemaining);
-    if (remaining === 0) {
-      return quota.plan === 'pro' ? '0 left – using HF billing' : '0 left – enable billing';
-    }
-    return `${remaining} left today`;
-  })();
-
   return (
     <Box
       sx={{
@@ -793,25 +735,8 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
                         }}
                       />
                     )}
-                    {isPremiumModel(model) && premiumChip && (
-                      <Chip
-                        label={premiumChip}
-                        size="small"
-                        sx={{
-                          height: '18px',
-                          fontSize: '10px',
-                          bgcolor: 'rgba(255,255,255,0.08)',
-                          color: 'var(--muted-text)',
-                          fontWeight: 600,
-                        }}
-                      />
-                    )}
                   </Box>
                 }
-                secondary={model.description}
-                secondaryTypographyProps={{
-                  sx: { fontSize: '12px', color: 'var(--muted-text)' }
-                }}
               />
             </MenuItem>
           ))}

frontend/src/components/Layout/AppLayout.tsx

@@ -7,6 +7,7 @@ import {
   IconButton,
   Alert,
   AlertTitle,
+  Button,
   Snackbar,
   useMediaQuery,
   useTheme,
@@ -26,6 +27,7 @@ import CodePanel from '@/components/CodePanel/CodePanel';
 import WelcomeScreen from '@/components/WelcomeScreen/WelcomeScreen';
 import YoloControl from '@/components/YoloControl';
 import { apiFetch } from '@/utils/api';
+import { inferenceCreditCta, isInferenceCreditError } from '@/utils/inferenceBilling';
 
 const DRAWER_WIDTH = 260;
 
@@ -183,6 +185,18 @@ export default function AppLayout() {
       ? 'LLM Provider Unreachable'
       : 'LLM Error'
     : '';
+  const llmCreditCta =
+    llmHealthError && isInferenceCreditError(llmHealthError.error, llmHealthError.errorType)
+      ? inferenceCreditCta(user?.plan)
+      : null;
+
+  const trackHealthProClick = () => {
+    if (user?.plan === 'pro' || !activeSessionId) return;
+    void apiFetch(`/api/pro-click/${activeSessionId}`, {
+      method: 'POST',
+      body: JSON.stringify({ source: 'llm_health_credit_error', target: 'hf_pro' }),
+    }).catch(() => {});
+  };
 
   // -- Welcome screen: no sessions at all ---------------------------------
   if (!hasAnySessions) {
@@ -466,6 +480,36 @@ export default function AppLayout() {
               {llmHealthError.model} — {llmHealthError.error.slice(0, 150)}
             </Typography>
           )}
+          {llmCreditCta && (
+            <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.75, mt: 1 }}>
+              <Button
+                component="a"
+                href={llmCreditCta.primaryHref}
+                target="_blank"
+                rel="noopener noreferrer"
+                color="inherit"
+                size="small"
+                variant="outlined"
+                onClick={trackHealthProClick}
+                sx={{ textTransform: 'none' }}
+              >
+                {llmCreditCta.primaryLabel}
+              </Button>
+              {llmCreditCta.secondaryHref && llmCreditCta.secondaryLabel && (
+                <Button
+                  component="a"
+                  href={llmCreditCta.secondaryHref}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  color="inherit"
+                  size="small"
+                  sx={{ textTransform: 'none' }}
+                >
+                  {llmCreditCta.secondaryLabel}
+                </Button>
+              )}
+            </Box>
+          )}
         </Alert>
       </Snackbar>
     </Box>

frontend/src/components/SessionChat.tsx

@@ -12,10 +12,7 @@ import { useSessionStore } from '@/store/sessionStore';
 import MessageList from '@/components/Chat/MessageList';
 import ChatInput from '@/components/Chat/ChatInput';
 import ExpiredBanner from '@/components/Chat/ExpiredBanner';
-import BillingBanner from '@/components/Chat/BillingBanner';
 import ChatErrorBanner from '@/components/Chat/ChatErrorBanner';
-import { useUserQuota } from '@/hooks/useUserQuota';
-import { isPremiumPath } from '@/utils/model';
 import { apiFetch } from '@/utils/api';
 import { logger } from '@/utils/logger';
 
@@ -88,46 +85,6 @@ export default function SessionChat({ sessionId, isActive, onSessionDead }: Sess
   // SDK status is the ground truth — if it's streaming/submitted, agent is busy
   const sdkBusy = status === 'streaming' || status === 'submitted';
   const busy = isProcessing || sdkBusy;
-  const { quota, refresh: refreshQuota } = useUserQuota({ enabled: isActive });
-
-  // Whether this session's premium usage is being billed to the user's own HF
-  // account (past the subsidized daily allowance). Re-read after each turn,
-  // since the backend flips it at submit time. Only premium-model sessions can
-  // ever be user-billed, so skip the fetch for free models.
-  const [premiumBilled, setPremiumBilled] = useState<boolean | null>(null);
-  const [premiumQuotaCounted, setPremiumQuotaCounted] = useState<boolean | null>(null);
-  const onPremiumModel = isPremiumPath(sessionMeta?.model ?? undefined);
-  useEffect(() => {
-    if (!isActive || !onPremiumModel) {
-      setPremiumBilled(null);
-      setPremiumQuotaCounted(null);
-      return;
-    }
-    if (busy) return;
-    let cancelled = false;
-    apiFetch(`/api/session/${sessionId}`)
-      .then((r) => (r.ok ? r.json() : null))
-      .then((d) => {
-        if (!cancelled && d) {
-          setPremiumBilled(Boolean(d.premium_user_billed));
-          setPremiumQuotaCounted(Boolean(d.premium_quota_counted));
-        }
-      })
-      .catch(() => {});
-    return () => {
-      cancelled = true;
-    };
-  }, [busy, isActive, onPremiumModel, sessionId]);
-
-  const sessionPremiumBilled = premiumBilled ?? Boolean(sessionMeta?.premiumUserBilled);
-  const sessionPremiumQuotaCounted =
-    premiumQuotaCounted ?? Boolean(sessionMeta?.premiumQuotaCounted);
-  const premiumBillingNotice =
-    sessionPremiumBilled ||
-    (isActive &&
-      onPremiumModel &&
-      quota?.premiumRemaining === 0 &&
-      !sessionPremiumQuotaCounted);
 
   const handleSendMessage = useCallback(
     async (text: string) => {
@@ -175,7 +132,6 @@ export default function SessionChat({ sessionId, isActive, onSessionDead }: Sess
         <ExpiredBanner sessionId={sessionId} />
       ) : (
         <>
-          {premiumBillingNotice && <BillingBanner />}
           {chatError && (
             <ChatErrorBanner
               error={chatError}
@@ -192,8 +148,6 @@ export default function SessionChat({ sessionId, isActive, onSessionDead }: Sess
             onDatasetUploaded={refreshMessages}
             isProcessing={busy}
             disabled={!isConnected || activityStatus.type === 'waiting-approval'}
-            quota={quota}
-            refreshQuota={refreshQuota}
             placeholder={
               activityStatus.type === 'waiting-approval'
                 ? 'Approve or reject pending tools first...'

frontend/src/hooks/useAuth.ts

@@ -48,6 +48,7 @@ export function useAuth() {
               username: data.username,
               name: data.name,
               picture: data.picture,
+              plan: data.plan === 'pro' ? 'pro' : 'free',
             });
             logger.log('Authenticated as', data.username);
             return;
@@ -59,7 +60,7 @@ export function useAuth() {
         const statusData = await statusRes.json();
         if (!statusData.auth_enabled) {
           // Dev mode — no OAuth configured
-          if (!cancelled) setUser({ authenticated: true, username: 'dev' });
+          if (!cancelled) setUser({ authenticated: true, username: 'dev', plan: 'pro' });
           return;
         }
 
@@ -67,7 +68,7 @@ export function useAuth() {
         if (!cancelled) setUser(null);
       } catch {
         // Backend unreachable — assume dev mode
-        if (!cancelled) setUser({ authenticated: true, username: 'dev' });
+        if (!cancelled) setUser({ authenticated: true, username: 'dev', plan: 'pro' });
       }
     }
 

frontend/src/hooks/useUserQuota.ts

@@ -1,51 +0,0 @@
-/**
- * Reads the current user's premium-model daily quota + plan tier from the backend.
- *
- * Fetches once when the user becomes authenticated, and exposes a `refresh()`
- * that callers invoke after a successful session-create / model-switch so the
- * chip reflects the new count without a full page reload.
- */
-import { useCallback, useEffect, useState } from 'react';
-import { useAgentStore } from '@/store/agentStore';
-import { apiFetch } from '@/utils/api';
-
-export type PlanTier = 'free' | 'pro';
-
-export interface UserQuota {
-  plan: PlanTier;
-  premiumUsedToday: number;
-  premiumDailyCap: number;
-  premiumRemaining: number;
-}
-
-export function useUserQuota({ enabled = true }: { enabled?: boolean } = {}) {
-  const user = useAgentStore((s) => s.user);
-  const [quota, setQuota] = useState<UserQuota | null>(null);
-  const [loading, setLoading] = useState(false);
-
-  const refresh = useCallback(async () => {
-    if (!enabled || !user?.authenticated) return;
-    setLoading(true);
-    try {
-      const res = await apiFetch('/api/user/quota');
-      if (!res.ok) return;
-      const data = await res.json();
-      setQuota({
-        plan: (data.plan ?? 'free') as PlanTier,
-        premiumUsedToday: data.premium_used_today ?? 0,
-        premiumDailyCap: data.premium_daily_cap ?? 1,
-        premiumRemaining: data.premium_remaining ?? 0,
-      });
-    } catch {
-      /* backend unreachable — leave previous value */
-    } finally {
-      setLoading(false);
-    }
-  }, [enabled, user?.authenticated]);
-
-  useEffect(() => {
-    refresh();
-  }, [refresh]);
-
-  return { quota, loading, refresh };
-}

frontend/src/store/agentStore.ts

@@ -6,7 +6,7 @@
  *  - Connection / processing flags
  *  - Panel state (right panel — single-artifact pattern)
  *  - Plan state
- *  - User info / health and quota banners
+ *  - User info / health banners
  *  - Edited scripts (for hf_jobs code editing)
  *
  * Per-session state:

frontend/src/store/sessionStore.ts

@@ -33,8 +33,6 @@ interface SessionStore {
     is_active?: boolean;
     is_processing?: boolean;
     model?: string | null;
-    premium_user_billed?: boolean;
-    premium_quota_counted?: boolean;
     pending_approval?: unknown[] | null;
     auto_approval?: {
       enabled?: boolean;
@@ -73,8 +71,6 @@ export const useSessionStore = create<SessionStore>()(
           autoApprovalCostCapUsd: null,
           autoApprovalEstimatedSpendUsd: 0,
           autoApprovalRemainingUsd: null,
-          premiumUserBilled: false,
-          premiumQuotaCounted: false,
         };
         set((state) => ({
           sessions: [...state.sessions, newSession],
@@ -128,8 +124,6 @@ export const useSessionStore = create<SessionStore>()(
                 isActive: server.is_active ?? existing.isActive,
                 isProcessing: Boolean(server.is_processing),
                 model: server.model ?? existing.model ?? null,
-                premiumUserBilled: Boolean(server.premium_user_billed),
-                premiumQuotaCounted: Boolean(server.premium_quota_counted),
                 needsAttention: Boolean(server.pending_approval?.length) || existing.needsAttention,
                 expired: false,
                 ...(auto
@@ -159,8 +153,6 @@ export const useSessionStore = create<SessionStore>()(
               autoApprovalCostCapUsd: server.auto_approval?.cost_cap_usd ?? null,
               autoApprovalEstimatedSpendUsd: server.auto_approval?.estimated_spend_usd ?? 0,
               autoApprovalRemainingUsd: server.auto_approval?.remaining_usd ?? null,
-              premiumUserBilled: Boolean(server.premium_user_billed),
-              premiumQuotaCounted: Boolean(server.premium_quota_counted),
             };
             merged.push(newSession);
             byId.set(id, newSession);
@@ -252,13 +244,11 @@ export const useSessionStore = create<SessionStore>()(
     {
       name: 'hf-agent-sessions',
       partialize: (state) => ({
-        // Reset transient session flags so cold-load state is re-derived from
-        // the live GET /sessions list and current daily quota window.
+        // Reset transient processing so cold-load state is re-derived from
+        // the live GET /sessions list.
         sessions: state.sessions.map((s) => ({
           ...s,
           isProcessing: false,
-          premiumUserBilled: false,
-          premiumQuotaCounted: false,
         })),
         activeSessionId: state.activeSessionId,
       }),

frontend/src/types/agent.ts

@@ -33,8 +33,6 @@ export interface SessionMeta {
   autoApprovalCostCapUsd?: number | null;
   autoApprovalEstimatedSpendUsd?: number;
   autoApprovalRemainingUsd?: number | null;
-  premiumUserBilled?: boolean;
-  premiumQuotaCounted?: boolean;
 }
 
 export interface ToolApproval {
@@ -49,4 +47,5 @@ export interface User {
   username?: string;
   name?: string;
   picture?: string;
+  plan?: 'free' | 'pro';
 }

frontend/src/utils/inferenceBilling.ts

@@ -0,0 +1,40 @@
+export const INFERENCE_PROVIDERS_PRICING_URL = 'https://huggingface.co/docs/inference-providers/pricing';
+export const HF_PRO_SUBSCRIBE_URL = 'https://huggingface.co/subscribe/pro';
+
+export type PlanTier = 'free' | 'pro';
+
+export function isInferenceCreditError(error: string | undefined, errorType?: string): boolean {
+  if (errorType === 'credits') return true;
+  const value = (error ?? '').toLowerCase();
+  return (
+    value.includes('402') ||
+    (value.includes('credit') && (
+      value.includes('insufficient') ||
+      value.includes('exhausted') ||
+      value.includes('out of') ||
+      value.includes('billing')
+    ))
+  );
+}
+
+export function inferenceCreditCta(plan: PlanTier | undefined) {
+  if (plan === 'pro') {
+    return {
+      title: 'Inference credits exhausted',
+      message: 'Your HF account needs more Inference Providers credits before this model can continue.',
+      primaryLabel: 'View pricing',
+      primaryHref: INFERENCE_PROVIDERS_PRICING_URL,
+      secondaryLabel: null,
+      secondaryHref: null,
+    };
+  }
+
+  return {
+    title: 'Inference credits exhausted',
+    message: 'Upgrade to HF PRO for more monthly Inference Providers usage, or review pay-as-you-go pricing.',
+    primaryLabel: 'Upgrade to PRO',
+    primaryHref: HF_PRO_SUBSCRIBE_URL,
+    secondaryLabel: 'View pricing',
+    secondaryHref: INFERENCE_PROVIDERS_PRICING_URL,
+  };
+}

frontend/src/utils/model.ts

@@ -6,30 +6,10 @@
  * AVAILABLE_MODELS in backend/routes/agent.py.
  */
 
-export const CLAUDE_SONNET_46_MODEL_PATH = 'anthropic/claude-sonnet-4-6:fal-ai';
 export const CLAUDE_OPUS_48_MODEL_PATH = 'anthropic/claude-opus-4.8:fal-ai';
-export const CLAUDE_MODEL_PATH = CLAUDE_SONNET_46_MODEL_PATH;
 export const GPT_55_MODEL_PATH = 'openai/gpt-5.5:fal-ai';
-
-const PREMIUM_MODEL_PATHS = new Set([
-  CLAUDE_SONNET_46_MODEL_PATH,
-  CLAUDE_OPUS_48_MODEL_PATH,
-  GPT_55_MODEL_PATH,
-]);
-
-const PRO_ONLY_MODEL_PATHS = new Set([
-  CLAUDE_OPUS_48_MODEL_PATH,
-  GPT_55_MODEL_PATH,
-]);
+export const KIMI_K26_MODEL_PATH = 'moonshotai/Kimi-K2.6';
 
 export function isClaudePath(modelPath: string | undefined): boolean {
   return !!modelPath && modelPath.includes('anthropic');
 }
-
-export function isPremiumPath(modelPath: string | undefined): boolean {
-  return !!modelPath && PREMIUM_MODEL_PATHS.has(modelPath);
-}
-
-export function isProOnlyPath(modelPath: string | undefined): boolean {
-  return !!modelPath && PRO_ONLY_MODEL_PATHS.has(modelPath);
-}

tests/integration/test_live_thinking_models.py

@@ -82,7 +82,6 @@ async def test_live_default_router_model_does_not_replay_reasoning_metadata():
         DEFAULT_MODEL_ID,
         os.environ["HF_TOKEN"],
         reasoning_effort="low",
-        bill_to_user=True,
     )
 
     result = await _call_llm_streaming(

tests/unit/test_agent_model_gating.py

@@ -1,4 +1,4 @@
-"""Tests for premium model handling in backend/routes/agent.py."""
+"""Tests for hosted model handling in backend/routes/agent.py."""
 
 import sys
 from pathlib import Path
@@ -14,66 +14,48 @@ if str(_BACKEND_DIR) not in sys.path:
 from routes import agent  # noqa: E402
 
 
-@pytest.fixture(autouse=True)
-def _reset_quota_store():
-    agent.user_quotas._reset_for_tests()
-    yield
-    agent.user_quotas._reset_for_tests()
-
-
-def _premium_session(model: str = agent.DEFAULT_PREMIUM_MODEL_ID):
-    return SimpleNamespace(
-        claude_counted=False,
-        claude_counted_day=None,
-        session=SimpleNamespace(
-            config=SimpleNamespace(model_name=model),
-            premium_user_billed=False,
-        ),
-    )
-
-
-def test_premium_model_predicate_uses_router_ids_only():
-    assert agent._is_premium_model(agent.DEFAULT_PREMIUM_MODEL_ID)
-    assert agent._is_premium_model(agent.DEFAULT_OPUS_MODEL_ID)
-    assert agent._is_premium_model(agent.DEFAULT_GPT_MODEL_ID)
-    assert not agent._is_pro_only_premium_model(agent.DEFAULT_PREMIUM_MODEL_ID)
-    assert agent._is_pro_only_premium_model(agent.DEFAULT_OPUS_MODEL_ID)
-    assert agent._is_pro_only_premium_model(agent.DEFAULT_GPT_MODEL_ID)
-    assert agent._is_user_billed(agent.DEFAULT_PREMIUM_MODEL_ID)
-    assert not agent._is_premium_model("moonshotai/Kimi-K2.6")
-    assert not agent._is_premium_model("unsupported/model")
+def test_available_models_exclude_sonnet_and_have_no_pro_gate():
+    models = {model["id"]: model for model in agent.AVAILABLE_MODELS}
 
+    assert models[agent.DEFAULT_OPUS_MODEL_ID]["label"] == "Claude Opus 4.8"
+    assert models[agent.DEFAULT_OPUS_MODEL_ID]["recommended"] is True
+    assert "recommended" not in models[agent.DEFAULT_FREE_MODEL_ID]
+    assert all("minimum_plan" not in model for model in models.values())
+    assert all("tier" not in model for model in models.values())
 
-def test_available_models_mark_opus_and_gpt_as_pro_only():
-    models = {model["id"]: model for model in agent.AVAILABLE_MODELS}
 
-    assert models[agent.DEFAULT_PREMIUM_MODEL_ID]["label"] == "Claude Sonnet 4.6"
-    assert models[agent.DEFAULT_PREMIUM_MODEL_ID]["minimum_plan"] == "free"
-    assert models[agent.DEFAULT_OPUS_MODEL_ID]["minimum_plan"] == "pro"
-    assert models[agent.DEFAULT_GPT_MODEL_ID]["minimum_plan"] == "pro"
+def test_default_model_for_user_is_plan_aware():
+    assert agent._default_model_for_user({"plan": "pro"}) == agent.DEFAULT_OPUS_MODEL_ID
+    assert (
+        agent._default_model_for_user({"plan": "free"}) == agent.DEFAULT_FREE_MODEL_ID
+    )
+    assert agent._default_model_for_user({}) == agent.DEFAULT_FREE_MODEL_ID
 
 
 @pytest.mark.asyncio
-async def test_default_session_uses_configured_default_model():
-    model = await agent._model_override_for_new_session(None, None)
-
-    assert model is None
+async def test_empty_session_model_uses_plan_default():
+    assert (
+        await agent._model_override_for_new_session(None, {"plan": "pro"})
+        == agent.DEFAULT_OPUS_MODEL_ID
+    )
+    assert (
+        await agent._model_override_for_new_session(None, {"plan": "free"})
+        == agent.DEFAULT_FREE_MODEL_ID
+    )
 
 
 @pytest.mark.asyncio
-async def test_explicit_premium_session_allowed_for_authenticated_user():
+async def test_explicit_session_model_is_honored():
     model = await agent._model_override_for_new_session(
-        None,
-        agent.DEFAULT_PREMIUM_MODEL_ID,
+        agent.DEFAULT_GPT_MODEL_ID,
+        {"plan": "free"},
     )
 
-    assert model == agent.DEFAULT_PREMIUM_MODEL_ID
+    assert model == agent.DEFAULT_GPT_MODEL_ID
 
 
 @pytest.mark.asyncio
-async def test_switching_to_premium_model_is_allowed_for_authenticated_user(
-    monkeypatch,
-):
+async def test_switching_to_opus_is_allowed_for_free_user(monkeypatch):
     updated = []
 
     async def fake_check_session_access(session_id, user, request=None):
@@ -93,25 +75,21 @@ async def test_switching_to_premium_model_is_allowed_for_authenticated_user(
 
     response = await agent.set_session_model(
         "s1",
-        {"model": agent.DEFAULT_PREMIUM_MODEL_ID},
+        {"model": agent.DEFAULT_OPUS_MODEL_ID},
         request=None,
         user={"user_id": "u1", "plan": "free"},
     )
 
-    assert response == {"session_id": "s1", "model": agent.DEFAULT_PREMIUM_MODEL_ID}
-    assert updated == [("s1", agent.DEFAULT_PREMIUM_MODEL_ID)]
+    assert response == {"session_id": "s1", "model": agent.DEFAULT_OPUS_MODEL_ID}
+    assert updated == [("s1", agent.DEFAULT_OPUS_MODEL_ID)]
 
 
 @pytest.mark.asyncio
-async def test_switching_to_pro_only_premium_model_is_allowed_for_pro_user(
-    monkeypatch,
-):
+async def test_switching_to_gpt_is_allowed_for_free_user(monkeypatch):
     updated = []
 
     async def fake_check_session_access(session_id, user, request=None):
-        assert session_id == "s1"
-        assert user["user_id"] == "u1"
-        return SimpleNamespace(user_id="u1")
+        return SimpleNamespace(user_id=user["user_id"])
 
     async def fake_update_session_model(session_id, model_id):
         updated.append((session_id, model_id))
@@ -127,38 +105,13 @@ async def test_switching_to_pro_only_premium_model_is_allowed_for_pro_user(
         "s1",
         {"model": agent.DEFAULT_GPT_MODEL_ID},
         request=None,
-        user={"user_id": "u1", "plan": "pro"},
+        user={"user_id": "u1", "plan": "free"},
     )
 
     assert response == {"session_id": "s1", "model": agent.DEFAULT_GPT_MODEL_ID}
     assert updated == [("s1", agent.DEFAULT_GPT_MODEL_ID)]
 
 
-@pytest.mark.asyncio
-async def test_switching_to_pro_only_premium_model_is_rejected_for_free_user(
-    monkeypatch,
-):
-    async def fake_check_session_access(session_id, user, request=None):
-        return SimpleNamespace(user_id=user["user_id"])
-
-    async def fail_if_updated(session_id, model_id):
-        raise AssertionError("free users should not switch to pro-only models")
-
-    monkeypatch.setattr(agent, "_check_session_access", fake_check_session_access)
-    monkeypatch.setattr(agent.session_manager, "update_session_model", fail_if_updated)
-
-    with pytest.raises(HTTPException) as exc_info:
-        await agent.set_session_model(
-            "s1",
-            {"model": agent.DEFAULT_GPT_MODEL_ID},
-            request=None,
-            user={"user_id": "u1", "plan": "free"},
-        )
-
-    assert exc_info.value.status_code == 403
-    assert exc_info.value.detail["error"] == "model_requires_pro"
-
-
 @pytest.mark.asyncio
 async def test_switching_to_unknown_model_id_is_rejected(monkeypatch):
     async def fake_check_session_access(session_id, user, request=None):
@@ -179,232 +132,8 @@ async def test_switching_to_unknown_model_id_is_rejected(monkeypatch):
 
 
 @pytest.mark.asyncio
-async def test_premium_quota_charges_without_user_billing_inside_allowance(monkeypatch):
-    persisted = []
-
-    async def fake_persist_session_snapshot(agent_session):
-        persisted.append(agent_session)
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fake_persist_session_snapshot,
-    )
-
-    agent_session = _premium_session()
-
-    await agent._enforce_premium_model_quota(
-        {"user_id": "u1", "plan": "free"},
-        agent_session,
-    )
-
-    assert agent_session.claude_counted is True
-    assert agent_session.claude_counted_day == agent.user_quotas.current_quota_day()
-    assert agent_session.session.premium_user_billed is False
-    assert persisted == [agent_session]
-    assert await agent.user_quotas.get_claude_used_today("u1") == 1
-
-
-@pytest.mark.asyncio
-async def test_premium_quota_counts_same_session_once_per_day(monkeypatch):
-    async def fake_persist_session_snapshot(_agent_session):
-        return None
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fake_persist_session_snapshot,
-    )
-
-    agent_session = _premium_session()
-
-    await agent._enforce_premium_model_quota(
-        {"user_id": "u1", "plan": "free"},
-        agent_session,
-    )
-    await agent._enforce_premium_model_quota(
-        {"user_id": "u1", "plan": "free"},
-        agent_session,
-    )
-
-    assert agent_session.claude_counted is True
-    assert agent_session.claude_counted_day == agent.user_quotas.current_quota_day()
-    assert await agent.user_quotas.get_claude_used_today("u1") == 1
-
-
-@pytest.mark.asyncio
-async def test_premium_quota_counts_stale_session_again_today(monkeypatch):
-    async def fake_persist_session_snapshot(_agent_session):
-        return None
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fake_persist_session_snapshot,
-    )
-
-    agent_session = _premium_session()
-    agent_session.claude_counted = True
-    agent_session.claude_counted_day = "2000-01-01"
-    agent_session.session.premium_user_billed = True
-
-    await agent._enforce_premium_model_quota(
-        {"user_id": "u1", "plan": "free"},
-        agent_session,
-    )
-
-    assert agent_session.claude_counted is True
-    assert agent_session.claude_counted_day == agent.user_quotas.current_quota_day()
-    assert agent_session.session.premium_user_billed is False
-    assert await agent.user_quotas.get_claude_used_today("u1") == 1
-
-
-@pytest.mark.asyncio
-async def test_free_user_gets_two_subsidized_premium_sessions_then_user_billing(
-    monkeypatch,
-):
-    async def fake_persist_session_snapshot(_agent_session):
-        return None
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fake_persist_session_snapshot,
-    )
-
-    first = _premium_session()
-    await agent._enforce_premium_model_quota({"user_id": "g1", "plan": "free"}, first)
-    assert first.session.premium_user_billed is False
-
-    second = _premium_session()
-    await agent._enforce_premium_model_quota({"user_id": "g1", "plan": "free"}, second)
-    assert second.session.premium_user_billed is False
-
-    third = _premium_session()
-    await agent._enforce_premium_model_quota({"user_id": "g1", "plan": "free"}, third)
-    assert third.session.premium_user_billed is True
-    assert third.claude_counted_day == agent.user_quotas.current_quota_day()
-    assert await agent.user_quotas.get_claude_used_today("g1") == 2
-
-
-@pytest.mark.asyncio
-async def test_free_model_does_not_consume_premium_quota(monkeypatch):
-    async def fail_if_persisted(_agent_session):
-        raise AssertionError("free model should not consume premium quota")
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fail_if_persisted,
-    )
-
-    agent_session = _premium_session("moonshotai/Kimi-K2.6")
-
-    await agent._enforce_premium_model_quota(
-        {"user_id": "u1", "plan": "free"},
-        agent_session,
-    )
-
-    assert agent_session.claude_counted is False
-    assert agent_session.claude_counted_day is None
-    assert await agent.user_quotas.get_claude_used_today("u1") == 0
-
-
-@pytest.mark.asyncio
-async def test_free_user_cannot_spend_quota_on_pro_only_premium_model(monkeypatch):
-    async def fail_if_persisted(_agent_session):
-        raise AssertionError("rejected model should not persist quota state")
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fail_if_persisted,
-    )
-
-    agent_session = _premium_session(agent.DEFAULT_OPUS_MODEL_ID)
-
-    with pytest.raises(HTTPException) as exc_info:
-        await agent._enforce_premium_model_quota(
-            {"user_id": "u1", "plan": "free"},
-            agent_session,
-        )
-
-    assert exc_info.value.status_code == 403
-    assert exc_info.value.detail["error"] == "model_requires_pro"
-    assert agent_session.claude_counted is False
-    assert agent_session.claude_counted_day is None
-    assert await agent.user_quotas.get_claude_used_today("u1") == 0
-
-
-@pytest.mark.asyncio
-async def test_downgraded_user_cannot_continue_counted_pro_only_session(monkeypatch):
-    async def fail_if_persisted(_agent_session):
-        raise AssertionError("already-counted rejected session should not persist")
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fail_if_persisted,
-    )
-
-    agent_session = _premium_session(agent.DEFAULT_OPUS_MODEL_ID)
-    agent_session.claude_counted = True
-
-    with pytest.raises(HTTPException) as exc_info:
-        await agent._enforce_premium_model_quota(
-            {"user_id": "u1", "plan": "free"},
-            agent_session,
-        )
-
-    assert exc_info.value.status_code == 403
-    assert exc_info.value.detail["error"] == "model_requires_pro"
-    assert agent_session.claude_counted is True
-    assert await agent.user_quotas.get_claude_used_today("u1") == 0
-
-
-@pytest.mark.asyncio
-async def test_pro_user_uses_pro_premium_quota(monkeypatch):
-    async def fake_persist_session_snapshot(_agent_session):
-        return None
-
-    monkeypatch.setattr(
-        agent.session_manager,
-        "persist_session_snapshot",
-        fake_persist_session_snapshot,
-    )
-
-    for index in range(2):
-        agent_session = _premium_session()
-        await agent._enforce_premium_model_quota(
-            {"user_id": "pro-user", "plan": "pro"},
-            agent_session,
-        )
-        assert agent_session.claude_counted is True
-        assert agent_session.claude_counted_day == agent.user_quotas.current_quota_day()
-        assert agent_session.session.premium_user_billed is False
-        assert await agent.user_quotas.get_claude_used_today("pro-user") == index + 1
-
-
-@pytest.mark.asyncio
-async def test_pro_user_billable_overflow_also_bills_user(monkeypatch):
-    async def fake_persist(_agent_session):
-        return None
-
-    monkeypatch.setattr(agent.session_manager, "persist_session_snapshot", fake_persist)
-    monkeypatch.setattr(agent.user_quotas, "daily_cap_for", lambda plan: 1)
-
-    await agent._enforce_premium_model_quota(
-        {"user_id": "p1", "plan": "pro"}, _premium_session()
-    )
-    over = _premium_session()
-    await agent._enforce_premium_model_quota({"user_id": "p1", "plan": "pro"}, over)
-    assert over.session.premium_user_billed is True
-
-
-@pytest.mark.asyncio
-async def test_restore_summary_enforces_premium_quota_before_seed(monkeypatch):
+async def test_restore_summary_uses_default_model_without_quota_gate(monkeypatch):
     events = []
-    agent_session = _premium_session()
 
     class Request:
         headers = {}
@@ -418,21 +147,14 @@ async def test_restore_summary_enforces_premium_quota_before_seed(monkeypatch):
         session_id, user, request, preload_sandbox=True
     ):
         events.append(("check", session_id, preload_sandbox))
-        return agent_session
-
-    async def fake_enforce_quota(user, session):
-        assert user["user_id"] == "u1"
-        assert session is agent_session
-        session.session.premium_user_billed = True
-        events.append(("quota", session.session.config.model_name))
+        return SimpleNamespace(session=SimpleNamespace(config=SimpleNamespace()))
 
     async def fake_seed(session_id, messages):
-        events.append(("seed", session_id, agent_session.session.premium_user_billed))
+        events.append(("seed", session_id))
         return len(messages)
 
     monkeypatch.setattr(agent.session_manager, "create_session", fake_create_session)
     monkeypatch.setattr(agent, "_check_session_access", fake_check_session_access)
-    monkeypatch.setattr(agent, "_enforce_premium_model_quota", fake_enforce_quota)
     monkeypatch.setattr(agent.session_manager, "seed_from_summary", fake_seed)
 
     response = await agent.restore_session_summary(
@@ -442,73 +164,9 @@ async def test_restore_summary_enforces_premium_quota_before_seed(monkeypatch):
     )
 
     assert response.session_id == "s1"
+    assert response.model == agent.DEFAULT_FREE_MODEL_ID
     assert events == [
-        ("create", None),
+        ("create", agent.DEFAULT_FREE_MODEL_ID),
         ("check", "s1", False),
-        ("quota", agent.DEFAULT_PREMIUM_MODEL_ID),
-        ("seed", "s1", True),
-    ]
-
-
-@pytest.mark.asyncio
-async def test_user_quota_response_uses_premium_fields_only(monkeypatch):
-    async def fake_get_used_today(user_id):
-        assert user_id == "u1"
-        return 2
-
-    monkeypatch.setattr(agent.user_quotas, "get_claude_used_today", fake_get_used_today)
-    monkeypatch.setattr(agent.user_quotas, "daily_cap_for", lambda plan: 5)
-
-    response = await agent.get_user_quota({"user_id": "u1", "plan": "pro"})
-
-    assert response == {
-        "plan": "pro",
-        "premium_used_today": 2,
-        "premium_daily_cap": 5,
-        "premium_remaining": 3,
-    }
-
-
-@pytest.mark.asyncio
-async def test_set_session_yolo_calls_manager_with_cap_presence(monkeypatch):
-    async def fake_check_session_access(session_id, user, request=None):
-        assert session_id == "s1"
-        assert user["user_id"] == "u1"
-        return object()
-
-    calls = []
-
-    async def fake_update_session_auto_approval(session_id, **kwargs):
-        calls.append((session_id, kwargs))
-        return {
-            "enabled": kwargs["enabled"],
-            "cost_cap_usd": 7.5,
-            "estimated_spend_usd": 0.0,
-            "remaining_usd": 7.5,
-        }
-
-    monkeypatch.setattr(agent, "_check_session_access", fake_check_session_access)
-    monkeypatch.setattr(
-        agent.session_manager,
-        "update_session_auto_approval",
-        fake_update_session_auto_approval,
-    )
-
-    response = await agent.set_session_yolo(
-        "s1",
-        agent.SessionYoloRequest(enabled=True, cost_cap_usd=7.5),
-        {"user_id": "u1"},
-    )
-
-    assert response["enabled"] is True
-    assert response["remaining_usd"] == 7.5
-    assert calls == [
-        (
-            "s1",
-            {
-                "enabled": True,
-                "cost_cap_usd": 7.5,
-                "cap_provided": True,
-            },
-        )
+        ("seed", "s1"),
     ]

tests/unit/test_cli_local_models.py

@@ -1,7 +1,9 @@
 import pytest
 
+from agent.config import load_config
 from agent.core import model_switcher
 from agent.core.local_models import is_local_model_id
+from agent.main import CLI_CONFIG_PATH
 
 
 def test_local_model_helper_accepts_supported_prefixes():
@@ -33,11 +35,16 @@ def test_openai_compat_prefix_is_not_supported():
 def test_suggested_models_include_router_claude_models_and_no_native_ids():
     ids = {m["id"] for m in model_switcher.SUGGESTED_MODELS}
 
-    assert "anthropic/claude-sonnet-4-6:fal-ai" in ids
     assert "anthropic/claude-opus-4.8:fal-ai" in ids
     assert all(model_id.count("/") >= 1 for model_id in ids)
 
 
+def test_cli_default_model_is_opus():
+    config = load_config(CLI_CONFIG_PATH)
+
+    assert config.model_name == "anthropic/claude-opus-4.8:fal-ai"
+
+
 def test_model_switcher_accepts_router_model_ids():
     assert model_switcher.is_valid_model_id("openai/gpt-5.5:fal-ai")
     assert model_switcher.is_valid_model_id("openai/gpt-oss-120b")

tests/unit/test_llm_params.py

@@ -9,22 +9,18 @@ from agent.core.llm_params import (
 from agent.core.model_ids import HF_ROUTER_BASE_URL
 
 
-def test_hf_router_params_for_default_premium_model(monkeypatch):
-    monkeypatch.setenv("INFERENCE_TOKEN", "inference-token")
-    monkeypatch.setenv("HF_BILL_TO", "smolagents")
-
+def test_hf_router_params_for_default_model_uses_session_token():
     params = _resolve_llm_params(
-        "anthropic/claude-sonnet-4-6:fal-ai",
+        "anthropic/claude-opus-4.8:fal-ai",
         "session-token",
         reasoning_effort="high",
         strict=True,
     )
 
     assert params == {
-        "model": "openai/anthropic/claude-sonnet-4-6:fal-ai",
+        "model": "openai/anthropic/claude-opus-4.8:fal-ai",
         "api_base": HF_ROUTER_BASE_URL,
-        "api_key": "inference-token",
-        "extra_headers": {"X-HF-Bill-To": "smolagents"},
+        "api_key": "session-token",
         "extra_body": {"reasoning_effort": "high"},
     }
 
@@ -52,57 +48,29 @@ def test_hf_router_drops_unsupported_effort_in_non_strict_mode(monkeypatch):
     assert "extra_body" not in params
 
 
-def test_user_billed_premium_uses_session_token_without_bill_to(monkeypatch):
-    monkeypatch.setenv("INFERENCE_TOKEN", "inference-token")
-    monkeypatch.setenv("HF_BILL_TO", "smolagents")
-
-    params = _resolve_llm_params(
-        "anthropic/claude-opus-4.8:fal-ai",
-        "session-token",
-        reasoning_effort="high",
-        strict=True,
-        bill_to_user=True,
-    )
-
-    assert params["model"] == "openai/anthropic/claude-opus-4.8:fal-ai"
-    assert params["api_base"] == HF_ROUTER_BASE_URL
-    assert params["api_key"] == "session-token"
-    assert "extra_headers" not in params
-    assert params["extra_body"] == {"reasoning_effort": "high"}
-
-
-def test_user_billed_premium_does_not_fall_back_to_cached_token(monkeypatch):
+def test_router_params_fall_back_to_hf_cache_when_session_token_missing(monkeypatch):
     import huggingface_hub
 
-    monkeypatch.setenv("INFERENCE_TOKEN", "inference-token")
     monkeypatch.setenv("HF_TOKEN", "server-token")
     monkeypatch.setattr(huggingface_hub, "get_token", lambda: "cached-token")
 
     params = _resolve_llm_params(
         "anthropic/claude-opus-4.8:fal-ai",
         None,
-        bill_to_user=True,
     )
 
-    assert params["api_key"] is None
+    assert params["api_key"] == "cached-token"
     assert "extra_headers" not in params
 
 
-def test_bill_to_user_ignored_for_free_models(monkeypatch):
-    monkeypatch.setenv("INFERENCE_TOKEN", "inference-token")
-    monkeypatch.setenv("HF_BILL_TO", "smolagents")
-
-    params = _resolve_llm_params(
-        "moonshotai/Kimi-K2.6", "session-token", bill_to_user=True
-    )
-
-    assert params["api_key"] == "inference-token"
-    assert params["extra_headers"] == {"X-HF-Bill-To": "smolagents"}
+def test_router_params_never_set_bill_to_headers():
+    params = _resolve_llm_params("moonshotai/Kimi-K2.6", "session-token")
 
+    assert params["api_key"] == "session-token"
+    assert "extra_headers" not in params
 
-def test_huggingface_prefix_is_stripped_for_router_calls(monkeypatch):
-    monkeypatch.setenv("INFERENCE_TOKEN", "inference-token")
 
+def test_huggingface_prefix_is_stripped_for_router_calls():
     params = _resolve_llm_params("huggingface/openai/gpt-5.5:fal-ai")
 
     assert params["model"] == "openai/openai/gpt-5.5:fal-ai"
@@ -196,22 +164,13 @@ def test_empty_local_model_id_is_not_treated_as_hf_router():
         _resolve_llm_params("ollama/")
 
 
-def test_hf_router_token_prefers_inference_token(monkeypatch):
-    monkeypatch.setenv("INFERENCE_TOKEN", " inference-token ")
-    monkeypatch.setenv("HF_TOKEN", "hf-token")
-
-    assert _resolve_hf_router_token("session-token") == "inference-token"
-
-
 def test_hf_router_token_prefers_session_over_hf_cache(monkeypatch):
-    monkeypatch.delenv("INFERENCE_TOKEN", raising=False)
     monkeypatch.setenv("HF_TOKEN", "hf-token")
 
     assert _resolve_hf_router_token(" session-token ") == "session-token"
 
 
 def test_hf_router_token_uses_hf_token_env_via_huggingface_hub(monkeypatch):
-    monkeypatch.delenv("INFERENCE_TOKEN", raising=False)
     monkeypatch.setenv("HF_TOKEN", " hf-token ")
 
     assert _resolve_hf_router_token(None) == "hf-token"
@@ -220,7 +179,6 @@ def test_hf_router_token_uses_hf_token_env_via_huggingface_hub(monkeypatch):
 def test_hf_router_token_uses_huggingface_hub_cache(monkeypatch):
     import huggingface_hub
 
-    monkeypatch.delenv("INFERENCE_TOKEN", raising=False)
     monkeypatch.delenv("HF_TOKEN", raising=False)
     monkeypatch.setattr(huggingface_hub, "get_token", lambda: "cached-token")
 
@@ -233,21 +191,22 @@ def test_hf_router_token_swallows_huggingface_hub_errors(monkeypatch):
     def fail():
         raise RuntimeError("cache unavailable")
 
-    monkeypatch.delenv("INFERENCE_TOKEN", raising=False)
     monkeypatch.delenv("HF_TOKEN", raising=False)
     monkeypatch.setattr(huggingface_hub, "get_token", fail)
 
     assert _resolve_hf_router_token(None) is None
 
 
-def test_hf_router_params_set_bill_to_only_for_inference_token(monkeypatch):
-    monkeypatch.setenv("INFERENCE_TOKEN", "inference-token")
-    monkeypatch.setenv("HF_BILL_TO", "test-org")
+def test_hf_router_params_allow_missing_token_without_headers(monkeypatch):
+    import huggingface_hub
+
+    monkeypatch.delenv("HF_TOKEN", raising=False)
+    monkeypatch.setattr(huggingface_hub, "get_token", lambda: None)
 
     params = _resolve_llm_params("moonshotai/Kimi-K2.6")
 
-    assert params["api_key"] == "inference-token"
-    assert params["extra_headers"] == {"X-HF-Bill-To": "test-org"}
+    assert params["api_key"] is None
+    assert "extra_headers" not in params
 
 
 def test_hf_request_token_keeps_browser_user_precedence(monkeypatch):

tests/unit/test_prompt_caching.py

@@ -6,7 +6,7 @@ from agent.core.prompt_caching import with_prompt_cache_params, with_prompt_cach
 
 def _anthropic_fal_params() -> dict:
     return {
-        "model": "openai/anthropic/claude-sonnet-4-6:fal-ai",
+        "model": "openai/anthropic/claude-opus-4.8:fal-ai",
         "api_base": HF_ROUTER_BASE_URL,
     }
 
@@ -167,7 +167,7 @@ def test_prompt_caching_is_noop_for_non_router_fal_model():
         {"role": "user", "content": "current question"},
     ]
     llm_params = {
-        "model": "openai/anthropic/claude-sonnet-4-6:fal-ai",
+        "model": "openai/anthropic/claude-opus-4.8:fal-ai",
         "api_base": "http://localhost:8000/v1",
     }
 

tests/unit/test_session_manager_persistence.py

@@ -16,7 +16,7 @@ _BACKEND_DIR = Path(__file__).resolve().parent.parent.parent / "backend"
 if str(_BACKEND_DIR) not in sys.path:
     sys.path.insert(0, str(_BACKEND_DIR))
 
-from agent.core.model_ids import DEFAULT_MODEL_ID, KIMI_K26_MODEL_ID  # noqa: E402
+from agent.core.model_ids import KIMI_K26_MODEL_ID  # noqa: E402
 from agent.core.session_persistence import NoopSessionStore  # noqa: E402
 from session_manager import AgentSession, SessionManager  # noqa: E402
 
@@ -128,32 +128,10 @@ def _runtime_agent_session(
     )
 
 
-def test_unknown_saved_model_defaults_to_claude():
-    model, premium_user_billed, claude_counted = (
-        SessionManager._model_from_saved_metadata(
-            "unsupported/model",
-            premium_user_billed=False,
-            claude_counted=False,
-        )
-    )
-
-    assert model == DEFAULT_MODEL_ID
-    assert premium_user_billed is False
-    assert claude_counted is False
-
-
-def test_unknown_saved_user_billed_model_defaults_to_free_model():
-    model, premium_user_billed, claude_counted = (
-        SessionManager._model_from_saved_metadata(
-            "unsupported/model",
-            premium_user_billed=True,
-            claude_counted=True,
-        )
-    )
+def test_unknown_saved_model_defaults_to_kimi():
+    model = SessionManager._model_from_saved_metadata("unsupported/model")
 
     assert model == KIMI_K26_MODEL_ID
-    assert premium_user_billed is False
-    assert claude_counted is False
 
 
 @pytest.mark.asyncio
@@ -755,9 +733,6 @@ async def test_list_sessions_dev_uses_store_dev_visibility():
                         "user_id": "alice",
                         "model": "m",
                         "created_at": datetime.now(UTC),
-                        "premium_user_billed": True,
-                        "claude_counted": True,
-                        "claude_counted_day": datetime.now(UTC).date().isoformat(),
                         "auto_approval_enabled": True,
                         "auto_approval_cost_cap_usd": 5.0,
                         "auto_approval_estimated_spend_usd": 2.0,
@@ -779,52 +754,9 @@ async def test_list_sessions_dev_uses_store_dev_visibility():
     assert store.seen_user_id == "dev"
     assert {session["session_id"] for session in sessions} == {"s1", "s2"}
     yolo = next(session for session in sessions if session["session_id"] == "s1")
-    assert yolo["premium_user_billed"] is True
-    assert yolo["premium_quota_counted"] is True
     assert yolo["auto_approval"] == {
         "enabled": True,
         "cost_cap_usd": 5.0,
         "estimated_spend_usd": 2.0,
         "remaining_usd": 3.0,
     }
-
-
-def test_get_session_info_marks_stale_premium_quota_as_unused_today():
-    manager = _manager_with_store(NoopSessionStore())
-    agent_session = _runtime_agent_session("s1", user_id="alice")
-    agent_session.claude_counted = True
-    agent_session.claude_counted_day = "2000-01-01"
-    agent_session.session.premium_user_billed = True
-    manager.sessions["s1"] = agent_session
-
-    info = manager.get_session_info("s1")
-
-    assert info is not None
-    assert info["premium_user_billed"] is False
-    assert info["premium_quota_counted"] is False
-
-
-@pytest.mark.asyncio
-async def test_list_sessions_marks_stale_premium_quota_as_unused_today():
-    class ListStore(NoopSessionStore):
-        enabled = True
-
-        async def list_sessions(self, user_id: str, **_: Any) -> list[dict[str, Any]]:
-            return [
-                {
-                    "session_id": "s1",
-                    "user_id": user_id,
-                    "model": "m",
-                    "created_at": datetime.now(UTC),
-                    "premium_user_billed": True,
-                    "claude_counted": True,
-                    "claude_counted_day": "2000-01-01",
-                }
-            ]
-
-    manager = _manager_with_store(ListStore())
-
-    sessions = await manager.list_sessions(user_id="alice")
-
-    assert sessions[0]["premium_user_billed"] is False
-    assert sessions[0]["premium_quota_counted"] is False

tests/unit/test_session_persistence.py

@@ -25,7 +25,6 @@ async def test_noop_store_keeps_local_cli_and_tests_db_free():
     assert await store.load_session("s1") is None
     assert await store.list_sessions("u1") == []
     assert await store.append_event("s1", "processing", {}) is None
-    assert await store.try_increment_quota("u1", "2099-01-01", 1) is None
 
 
 def test_unsafe_message_payload_is_replaced_with_marker():

tests/unit/test_user_quotas.py

@@ -1,141 +0,0 @@
-"""Tests for backend/user_quotas.py — the in-memory premium quota store."""
-
-import asyncio
-import sys
-from pathlib import Path
-
-import pytest
-
-# The backend package isn't on sys.path by default; add it so we can import
-# the module under test without pulling in the whole FastAPI app.
-_BACKEND_DIR = Path(__file__).resolve().parent.parent.parent / "backend"
-if str(_BACKEND_DIR) not in sys.path:
-    sys.path.insert(0, str(_BACKEND_DIR))
-
-import user_quotas  # noqa: E402
-from agent.core.session_persistence import NoopSessionStore, _reset_store_for_tests  # noqa: E402
-
-
-@pytest.fixture(autouse=True)
-def _reset_store():
-    """Fresh in-memory store per test."""
-    user_quotas._reset_for_tests()
-    yield
-    user_quotas._reset_for_tests()
-
-
-def test_daily_cap_for_known_plans():
-    assert user_quotas.daily_cap_for("free") == user_quotas.CLAUDE_FREE_DAILY
-    assert user_quotas.daily_cap_for("pro") == user_quotas.CLAUDE_PRO_DAILY
-    assert user_quotas.daily_cap_for("org") == user_quotas.CLAUDE_FREE_DAILY
-
-
-def test_daily_cap_for_unknown_or_missing_defaults_to_free():
-    assert user_quotas.daily_cap_for(None) == user_quotas.CLAUDE_FREE_DAILY
-    assert user_quotas.daily_cap_for("") == user_quotas.CLAUDE_FREE_DAILY
-    assert user_quotas.daily_cap_for("mystery") == user_quotas.CLAUDE_FREE_DAILY
-
-
-@pytest.mark.asyncio
-async def test_increment_and_read_back_same_day():
-    assert await user_quotas.get_claude_used_today("u1") == 0
-    assert await user_quotas.increment_claude("u1") == 1
-    assert await user_quotas.increment_claude("u1") == 2
-    assert await user_quotas.get_claude_used_today("u1") == 2
-
-
-@pytest.mark.asyncio
-async def test_independent_users_do_not_share_counts():
-    await user_quotas.increment_claude("alice")
-    await user_quotas.increment_claude("alice")
-    await user_quotas.increment_claude("bob")
-    assert await user_quotas.get_claude_used_today("alice") == 2
-    assert await user_quotas.get_claude_used_today("bob") == 1
-
-
-@pytest.mark.asyncio
-async def test_stale_day_resets_before_next_read():
-    await user_quotas.increment_claude("u1")
-    # Simulate yesterday's entry still in the store.
-    user_quotas._claude_counts["u1"] = ("2000-01-01", 99)
-    assert await user_quotas.get_claude_used_today("u1") == 0
-    # And a fresh increment starts from 0.
-    assert await user_quotas.increment_claude("u1") == 1
-
-
-@pytest.mark.asyncio
-async def test_concurrent_increments_under_lock_do_not_lose_writes():
-    """50 coroutines bumping the same user must land at exactly 50."""
-    await asyncio.gather(*[user_quotas.increment_claude("race") for _ in range(50)])
-    assert await user_quotas.get_claude_used_today("race") == 50
-
-
-@pytest.mark.asyncio
-async def test_try_increment_returns_none_at_cap():
-    assert await user_quotas.try_increment_claude("freebie", 1) == 1
-    assert await user_quotas.try_increment_claude("freebie", 1) is None
-    assert await user_quotas.get_claude_used_today("freebie") == 1
-
-
-@pytest.mark.asyncio
-async def test_try_increment_delegates_cap_to_enabled_store():
-    class StoreAtCap(NoopSessionStore):
-        enabled = True
-
-        async def try_increment_quota(self, user_id: str, day: str, cap: int):
-            assert user_id == "mongo-user"
-            assert cap == 1
-            return None
-
-        async def get_quota(self, user_id: str, day: str):
-            return 1
-
-    _reset_store_for_tests(StoreAtCap())
-
-    assert await user_quotas.try_increment_claude("mongo-user", 1) is None
-    assert await user_quotas.get_claude_used_today("mongo-user") == 1
-    assert "mongo-user" not in user_quotas._claude_counts
-
-
-@pytest.mark.asyncio
-async def test_refund_decrements_and_drops_entry_at_zero():
-    await user_quotas.increment_claude("u1")
-    assert await user_quotas.get_claude_used_today("u1") == 1
-    await user_quotas.refund_claude("u1")
-    assert await user_quotas.get_claude_used_today("u1") == 0
-    assert "u1" not in user_quotas._claude_counts
-
-
-@pytest.mark.asyncio
-async def test_refund_on_nonexistent_user_is_noop():
-    await user_quotas.refund_claude("ghost")  # should not raise
-    assert await user_quotas.get_claude_used_today("ghost") == 0
-
-
-@pytest.mark.asyncio
-async def test_refund_on_stale_day_resets_rather_than_underflow():
-    user_quotas._claude_counts["u1"] = ("2000-01-01", 5)
-    await user_quotas.refund_claude("u1")
-    # Stale entry dropped; today's count stays 0.
-    assert await user_quotas.get_claude_used_today("u1") == 0
-
-
-@pytest.mark.asyncio
-async def test_free_user_cap_reached_at_two():
-    cap = user_quotas.daily_cap_for("free")
-    assert cap == 2
-    assert await user_quotas.increment_claude("freebie") == 1
-    used = await user_quotas.increment_claude("freebie")
-    assert used == 2
-    assert used >= cap
-
-
-@pytest.mark.asyncio
-async def test_pro_user_cap_reached_at_twenty():
-    cap = user_quotas.daily_cap_for("pro")
-    assert cap == 20
-    for i in range(1, 21):
-        assert await user_quotas.increment_claude("pro_user") == i
-    # 21st would exceed — the gate in routes/agent.py enforces this; here
-    # we just confirm the counter tracks past the cap so that check works.
-    assert await user_quotas.increment_claude("pro_user") == 21