Set Sonnet as default premium model (#284)

* Set Sonnet as default premium model

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

* Address pro-only premium review feedback

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 Opus 4.8 through the HF Router (`anthropic/claude-opus-4.8: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`); 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`.
+- 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`.
 
 ## Development Checks
 

README.md

@@ -54,7 +54,7 @@ ml-intern "fine-tune llama on my dataset"
 **Options:**
 
 ```bash
-ml-intern --model anthropic/claude-opus-4.8:fal-ai "your prompt"
+ml-intern --model anthropic/claude-sonnet-4-6: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,6 +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.
+
 #### Local models
 
 Local model support uses OpenAI-compatible HTTP endpoints through LiteLLM. The
@@ -383,7 +386,7 @@ Edit `configs/cli_agent_config.json` for CLI defaults, or
 
 ```json
 {
-  "model_name": "anthropic/claude-opus-4.8:fal-ai",
+  "model_name": "anthropic/claude-sonnet-4-6:fal-ai",
   "mcpServers": {
     "your-server-name": {
       "transport": "http",

agent/core/model_ids.py

@@ -2,16 +2,24 @@
 
 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_OPUS_48_MODEL_ID
+DEFAULT_MODEL_ID = CLAUDE_SONNET_46_MODEL_ID
 
 PREMIUM_MODEL_IDS = {
+    CLAUDE_SONNET_46_MODEL_ID,
+    CLAUDE_OPUS_48_MODEL_ID,
+    GPT_55_MODEL_ID,
+}
+
+PRO_ONLY_PREMIUM_MODEL_IDS = {
     CLAUDE_OPUS_48_MODEL_ID,
     GPT_55_MODEL_ID,
 }
@@ -36,6 +44,11 @@ def is_premium_model_id(model_id: str | None) -> bool:
     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)

agent/core/model_switcher.py

@@ -28,6 +28,7 @@ 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,
@@ -39,6 +40,7 @@ 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/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-opus-4.8:fal-ai' or a supported local prefix."
+            "'anthropic/claude-sonnet-4-6:fal-ai' or a supported local prefix."
         )
     return model.removeprefix("huggingface/")
 

backend/routes/agent.py

@@ -55,6 +55,7 @@ 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,
@@ -62,6 +63,7 @@ from agent.core.model_ids import (
     KIMI_K26_MODEL_ID,
     MINIMAX_M27_MODEL_ID,
     is_premium_model_id,
+    is_pro_only_premium_model_id,
 )
 
 logger = logging.getLogger(__name__)
@@ -70,6 +72,7 @@ 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
 DATASET_UPLOAD_MULTIPART_SLACK_BYTES = 1024 * 1024
@@ -79,40 +82,53 @@ def _available_models() -> list[dict[str, Any]]:
     models = [
         {
             "id": DEFAULT_PREMIUM_MODEL_ID,
-            "label": "Claude Opus 4.8",
+            "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",
         },
         {
             "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
@@ -125,6 +141,32 @@ 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 _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):
+        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.",
+        },
+    )
+
+
 def _is_user_billed(model_id: str) -> bool:
     return _is_premium_model(model_id)
 
@@ -168,17 +210,19 @@ async def _enforce_premium_model_quota(
     ``claude_counted`` flag on ``AgentSession`` guards against re-counting the
     same session; the stored field name is kept for persistence compatibility.
 
-    Subsidizes the daily allowance (free = 2, pro = 20), organization-billed
-    through the HF Router. 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.
+    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.
     """
-    if agent_session.claude_counted:
-        return
     model_name = agent_session.session.config.model_name
     if not _is_premium_model(model_name):
         return
+    _reject_model_unavailable_for_plan(model_name, user)
+    if agent_session.claude_counted:
+        return
     user_id = user["user_id"]
     plan = user.get("plan", "free")
     cap = user_quotas.daily_cap_for(plan)
@@ -463,6 +507,7 @@ async def create_session(
     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)
 
     # Empty requests use the configured default, which may be premium.
     model = await _model_override_for_new_session(request, model)
@@ -508,6 +553,7 @@ async def restore_session_summary(
     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)
 
     model = await _model_override_for_new_session(request, model)
 
@@ -579,6 +625,7 @@ async def set_session_model(
     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)
     if not agent_session:
         raise HTTPException(status_code=404, detail="Session not found")
     await session_manager.update_session_model(session_id, model_id)

backend/user_quotas.py

@@ -8,12 +8,13 @@ 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 in a session, not raw messages. A user who
-sends with a premium model in a new session consumes one quota point; switching
-an already-counted session back to a premium model doesn't
-(`AgentSession.claude_counted` guards that).
+sends with an allowed premium model in a new session consumes one quota point;
+switching an already-counted session back to a premium model doesn't
+(`AgentSession.claude_counted` 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)
+  free user   → CLAUDE_FREE_DAILY (2) for the default premium model
   pro user    → CLAUDE_PRO_DAILY  (20)
 """
 

configs/cli_agent_config.json

@@ -1,5 +1,5 @@
 {
-  "model_name": "anthropic/claude-opus-4.8:fal-ai",
+  "model_name": "anthropic/claude-sonnet-4-6: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-opus-4.8:fal-ai}",
+  "model_name": "${ML_INTERN_DEFAULT_MODEL_ID:-anthropic/claude-sonnet-4-6:fal-ai}",
   "save_sessions": true,
   "session_dataset_repo": "smolagents/ml-intern-sessions",
   "share_traces": true,

frontend/src/components/Chat/ChatInput.tsx

@@ -20,15 +20,17 @@ 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 { UserQuota } from '@/hooks/useUserQuota';
+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,
   isClaudePath,
   isPremiumPath,
+  isProOnlyPath,
 } from '@/utils/model';
 
 // Model configuration
@@ -39,6 +41,7 @@ interface ModelOption {
   modelPath: string;
   avatarUrl: string;
   recommended?: boolean;
+  minimumPlan?: 'free' | 'pro';
 }
 
 const getHfAvatarUrl = (modelId: string) => {
@@ -48,19 +51,28 @@ const getHfAvatarUrl = (modelId: string) => {
 
 const DEFAULT_MODEL_OPTIONS: ModelOption[] = [
   {
-    id: 'claude-opus-4-8',
-    name: 'Claude Opus 4.8',
+    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',
+  },
   {
     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',
@@ -97,6 +109,7 @@ const normalizeModelPath = (path: string | undefined) => (
     .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 => {
@@ -129,6 +142,7 @@ const modelOptionFromApi = (model: {
   label?: string;
   provider?: string;
   recommended?: boolean;
+  minimum_plan?: string;
 }): ModelOption | null => {
   if (!model.id) return null;
   return {
@@ -138,6 +152,7 @@ const modelOptionFromApi = (model: {
     modelPath: model.id,
     avatarUrl: getHfAvatarUrl(model.id.replace(/^huggingface\//, '')),
     recommended: Boolean(model.recommended),
+    minimumPlan: model.minimum_plan === 'pro' ? 'pro' : 'free',
   };
 };
 
@@ -188,6 +203,12 @@ 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`;
@@ -269,7 +290,16 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
     return () => { cancelled = true; };
   }, [sessionId, updateSessionModel]);
 
-  const selectedModel = modelOptions.find(m => m.id === selectedModelId) || modelOptions[0];
+  const plan = quota?.plan ?? 'free';
+  const visibleModelOptions = modelOptions.filter((model) => (
+    isModelAllowedForPlan(model, plan)
+  ));
+  const selectedModel = (
+    visibleModelOptions.find(m => m.id === selectedModelId)
+    || modelOptions.find(m => m.id === selectedModelId)
+    || visibleModelOptions[0]
+    || modelOptions[0]
+  );
 
   // Auto-focus the textarea when the session becomes ready
   useEffect(() => {
@@ -279,11 +309,16 @@ 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]);
+  }, [input, disabled, isUploadingDataset, onSend, modelOptions, selectedModelId, plan]);
 
   const handleDatasetUploadClick = useCallback(() => {
     fileInputRef.current?.click();
@@ -389,6 +424,10 @@ 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',
@@ -718,7 +757,7 @@ export default function ChatInput({ sessionId, initialModelPath, onSend, onStop,
             }
           }}
         >
-          {modelOptions.map((model) => (
+          {visibleModelOptions.map((model) => (
             <MenuItem
               key={model.id}
               onClick={() => handleSelectModel(model)}

frontend/src/utils/model.ts

@@ -6,11 +6,18 @@
  * 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_OPUS_48_MODEL_PATH;
+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,
 ]);
@@ -22,3 +29,7 @@ export function isClaudePath(modelPath: string | undefined): boolean {
 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/unit/test_agent_model_gating.py

@@ -33,12 +33,25 @@ def _premium_session(model: str = agent.DEFAULT_PREMIUM_MODEL_ID):
 
 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_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"
+
+
 @pytest.mark.asyncio
 async def test_default_session_uses_configured_default_model():
     model = await agent._model_override_for_new_session(None, None)
@@ -79,15 +92,72 @@ async def test_switching_to_premium_model_is_allowed_for_authenticated_user(
 
     response = await agent.set_session_model(
         "s1",
-        {"model": agent.DEFAULT_GPT_MODEL_ID},
+        {"model": agent.DEFAULT_PREMIUM_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)]
+
+
+@pytest.mark.asyncio
+async def test_switching_to_pro_only_premium_model_is_allowed_for_pro_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")
+
+    async def fake_update_session_model(session_id, model_id):
+        updated.append((session_id, model_id))
+
+    monkeypatch.setattr(agent, "_check_session_access", fake_check_session_access)
+    monkeypatch.setattr(
+        agent.session_manager,
+        "update_session_model",
+        fake_update_session_model,
+    )
+
+    response = await agent.set_session_model(
+        "s1",
+        {"model": agent.DEFAULT_GPT_MODEL_ID},
+        request=None,
+        user={"user_id": "u1", "plan": "pro"},
+    )
+
     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):
@@ -182,6 +252,57 @@ async def test_free_model_does_not_consume_premium_quota(monkeypatch):
     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 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):

tests/unit/test_cli_local_models.py

@@ -30,9 +30,10 @@ def test_openai_compat_prefix_is_not_supported():
     assert not model_switcher.is_valid_model_id("openai-compat/custom-model")
 
 
-def test_suggested_models_include_router_opus48_and_no_native_ids():
+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)
 

tests/unit/test_llm_params.py

@@ -14,14 +14,14 @@ def test_hf_router_params_for_default_premium_model(monkeypatch):
     monkeypatch.setenv("HF_BILL_TO", "smolagents")
 
     params = _resolve_llm_params(
-        "anthropic/claude-opus-4.8:fal-ai",
+        "anthropic/claude-sonnet-4-6:fal-ai",
         "session-token",
         reasoning_effort="high",
         strict=True,
     )
 
     assert params == {
-        "model": "openai/anthropic/claude-opus-4.8:fal-ai",
+        "model": "openai/anthropic/claude-sonnet-4-6:fal-ai",
         "api_base": HF_ROUTER_BASE_URL,
         "api_key": "inference-token",
         "extra_headers": {"X-HF-Bill-To": "smolagents"},