Refresh Anovo model routing to GPT-OSS

Dockerfile

@@ -1,11 +1,12 @@
 FROM python:3.11-slim
-WORKDIR /app
 
-LABEL version="4.0"
+WORKDIR /app
 
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+
 COPY . .
 
 EXPOSE 7860
+
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -13,12 +13,16 @@ short_description: AI-powered writing tool backend (FastAPI)
 
 FastAPI backend for [Anovo](https://github.com/rushabhnixen/Anovo) — an open-source AI writing tool.
 
-## Required Secrets (set in Space Settings)
+## Required Secrets (set in Space Settings → Repository secrets)
 
 | Secret | Description |
 |---|---|
-| `JWT_SECRET_KEY` | Random string for JWT signing |
-| `GROQ_API_KEYS` | Comma-separated Groq API keys |
-| `GITHUB_PAT` | GitHub classic token (ghp_...) for premium models |
-| `ADMIN_EMAILS` | Comma-separated admin emails |
-| `PREMIUM_PROMO_CODES` | Comma-separated promo codes |
+| `JWT_SECRET_KEY` | Random 32-byte hex string — run `openssl rand -hex 32` |
+| `GROQ_API_KEY` | Free API key from [console.groq.com](https://console.groq.com) |
+
+## Optional Secrets
+
+| Secret | Default | Description |
+|---|---|---|
+| `DATABASE_URL` | `sqlite:///./anovo.db` | SQLite (default) or Postgres URL |
+| `CORS_ORIGINS` | Vercel + HF wildcards | JSON array of allowed origins |

config.py

@@ -20,15 +20,18 @@ class Settings(BaseSettings):
     # e.g. GROQ_API_KEYS=gsk_key1,gsk_key2,gsk_key3,gsk_key4
     groq_api_key: str = ""       # single key (backward compatible)
     groq_api_keys: str = ""      # comma-separated list of keys
-    groq_model: str = "llama-3.3-70b-versatile"
+    # Llama 3.3 70B is scheduled to shut down on Groq free/developer tiers on
+    # 2026-08-16. GPT-OSS 20B is the supported low-latency replacement.
+    groq_model: str = "openai/gpt-oss-20b"
 
     # HuggingFace Inference API — middle-tier fallback between Groq and local
     hf_api_token: str = ""
-    hf_model: str = "mistralai/Mistral-7B-Instruct-v0.3"
+    hf_model: str = "openai/gpt-oss-20b:fastest"
 
-    # GitHub Models (premium tier) — Meta-Llama-3.1-405B-Instruct
+    # Retained only so older deployments can boot while the secret is removed.
+    # GitHub Models was retired on 2026-07-30 and is no longer called.
     github_pat: str = ""
-    github_model: str = "Meta-Llama-3.1-405B-Instruct"
+    github_model: str = "gpt-oss-120b"
 
     # Premium promo codes (comma-separated)
     premium_promo_codes: str = ""

main.py

@@ -26,7 +26,7 @@ app = FastAPI(
         "translation, AI text humanization, plagiarism detection, "
         "tone analysis, co-writing, AI chat, and user accounts."
     ),
-    version="2.0.0",
+    version="2.1.0",
     docs_url="/docs",
     redoc_url="/redoc",
     lifespan=lifespan,
@@ -67,7 +67,7 @@ def health_check() -> dict:
         "providers": {
             "groq": bool(settings.groq_api_keys or settings.groq_api_key),
             "hf": bool(settings.hf_api_token),
-            "github_models": bool(settings.github_pat),
+            "premium_models": bool(settings.groq_api_keys or settings.groq_api_key),
         },
         "db": settings.database_url.split("///")[-1] if "sqlite" in settings.database_url else "postgres",
     }

models/schemas.py

@@ -7,7 +7,7 @@ from typing import Literal, Optional
 class ParaphraseRequest(BaseModel):
     text: str = Field(..., min_length=1, max_length=10000, description="Text to paraphrase")
     intensity: int = Field(3, ge=1, le=5, description="Paraphrase intensity (1=minimal, 5=aggressive)")
-    model: str = Field("standard", description="Model to use: 'standard' or a GitHub Models model name")
+    model: str = Field("standard", description="Model to use: 'standard' or a supported Anovo model profile")
     writing_mode: Literal[
         "standard", "fluency", "formal", "simple", "creative",
         "academic", "expand", "shorten", "humanize",
@@ -95,7 +95,7 @@ class TranslateResponse(BaseModel):
 
 class HumanizeRequest(BaseModel):
     text: str = Field(..., min_length=1, max_length=10000, description="Text to humanize")
-    model: str = Field("standard", description="Model to use: 'standard' or a GitHub Models model name")
+    model: str = Field("standard", description="Model to use: 'standard' or a supported Anovo model profile")
 
 
 class HumanizeResponse(BaseModel):
@@ -230,3 +230,17 @@ class AdminStatsResponse(BaseModel):
     premium_users: int
     admin_users: int
     total_history_entries: int
+
+
+class AdminModelInfo(BaseModel):
+    id: str
+    label: str
+    provider_model: str
+    status: Literal["production", "preview"]
+
+
+class AdminModelsResponse(BaseModel):
+    provider: str
+    provider_configured: bool
+    standard_model: str
+    models: list[AdminModelInfo]

routers/admin.py

@@ -4,14 +4,28 @@ from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy import func
 from sqlalchemy.orm import Session
 
+from config import settings
 from database import get_db
 from models.db_models import HistoryEntry, User
-from models.schemas import AdminStatsResponse, AdminUserUpdate, UserResponse
+from models.schemas import (
+    AdminModelInfo,
+    AdminModelsResponse,
+    AdminStatsResponse,
+    AdminUserUpdate,
+    UserResponse,
+)
 from routers.auth import _current_user_id
 from services.auth_service import get_user_by_id
+from services.llm_client import PREMIUM_MODEL_PROFILES
 
 router = APIRouter(prefix="/api/admin", tags=["admin"])
 
+MODEL_LABELS = {
+    "gpt-oss-120b": "GPT-OSS 120B",
+    "gpt-oss-20b": "GPT-OSS 20B",
+    "qwen-3.6-27b": "Qwen 3.6 27B",
+}
+
 
 def _require_admin(
     user_id: int = Depends(_current_user_id),
@@ -94,3 +108,24 @@ def get_stats(
         admin_users=admin_users,
         total_history_entries=total_history,
     )
+
+
+@router.get("/models", response_model=AdminModelsResponse, summary="Writing model status")
+def model_status(
+    admin: User = Depends(_require_admin),
+) -> AdminModelsResponse:
+    """Return safe, non-secret provider information for the admin dashboard."""
+    return AdminModelsResponse(
+        provider="Groq",
+        provider_configured=bool(settings.groq_api_keys or settings.groq_api_key),
+        standard_model=settings.groq_model,
+        models=[
+            AdminModelInfo(
+                id=profile,
+                label=MODEL_LABELS[profile],
+                provider_model=provider_model,
+                status="preview" if profile == "qwen-3.6-27b" else "production",
+            )
+            for profile, provider_model in PREMIUM_MODEL_PROFILES.items()
+        ],
+    )

routers/humanize.py

@@ -20,7 +20,7 @@ def humanize_endpoint(
     """
     Transform AI-generated text into more natural, human-sounding writing.
 
-    Set `model` to a GitHub Models model name to use premium mode
+    Set `model` to a supported Anovo model profile to use premium mode
     (requires authentication and premium account).
     """
     use_premium = request.model != "standard"

routers/paraphrase.py

@@ -26,7 +26,7 @@ def paraphrase_endpoint(
     """
     Paraphrase the given text with adjustable intensity.
 
-    Set `model` to a GitHub Models model name to use premium mode
+    Set `model` to a supported Anovo model profile to use premium mode
     (requires authentication and premium account).
     """
     use_premium = request.model != "standard"

services/humanize_service.py

@@ -5,7 +5,7 @@ Uses LLM (Groq / HF Inference) for high-quality humanization when available.
 Processes large texts by chunking into paragraphs and humanizing each chunk
 separately, then reassembling. Falls back to a local pipeline otherwise.
 
-Premium mode uses GitHub Models for superior rewriting quality.
+Premium mode uses the current Groq-hosted Anovo model profiles.
 """
 from __future__ import annotations
 
@@ -31,8 +31,8 @@ def humanize(text: str) -> dict:
         return result
 
 
-def humanize_premium(text: str, model: str = "Meta-Llama-3.1-405B-Instruct") -> dict:
-    """Humanize using a premium GitHub Models model."""
+def humanize_premium(text: str, model: str = "gpt-oss-120b") -> dict:
+    """Humanize using a premium writing model."""
     try:
         return _humanize_llm_premium(text, model)
     except RuntimeError:

services/llm_client.py

@@ -23,18 +23,28 @@ logger = logging.getLogger(__name__)
 
 GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
 HF_URL = "https://router.huggingface.co/v1/chat/completions"
-GITHUB_MODELS_URL = "https://models.inference.ai.azure.com/chat/completions"
-
-GITHUB_MODELS_AVAILABLE = [
-    "gpt-4o",
-    "gpt-4o-mini",
-    "Meta-Llama-3.1-405B-Instruct",
-    "Llama-3.3-70B-Instruct",
-    "Meta-Llama-3.1-8B-Instruct",
-    "Phi-4",
-    "DeepSeek-R1",
-    "Cohere-command-r-plus-08-2024",
-]
+# GitHub Models was fully retired on 2026-07-30. Keep stable Anovo profile
+# names and route them through models currently offered on Groq's free tier.
+PREMIUM_MODEL_PROFILES = {
+    "gpt-oss-120b": "openai/gpt-oss-120b",
+    "gpt-oss-20b": "openai/gpt-oss-20b",
+    "qwen-3.6-27b": "qwen/qwen3.6-27b",
+}
+
+# Existing web/extension clients may retain one of these values in storage.
+# Resolve them instead of returning a hard failure after the provider migration.
+LEGACY_MODEL_ALIASES = {
+    "gpt-4o": "openai/gpt-oss-120b",
+    "gpt-4o-mini": "openai/gpt-oss-20b",
+    "Meta-Llama-3.1-405B-Instruct": "openai/gpt-oss-120b",
+    "Llama-3.3-70B-Instruct": "openai/gpt-oss-120b",
+    "Meta-Llama-3.1-8B-Instruct": "openai/gpt-oss-20b",
+    "Phi-4": "openai/gpt-oss-20b",
+    "DeepSeek-R1": "openai/gpt-oss-120b",
+    "Cohere-command-r-plus-08-2024": "qwen/qwen3.6-27b",
+}
+
+ALLOWED_PREMIUM_MODELS = frozenset(PREMIUM_MODEL_PROFILES.values())
 
 
 class ProviderError(Exception):
@@ -136,45 +146,58 @@ def _rotate_from(start_key: str) -> list[str]:
     return _groq_keys[idx:] + _groq_keys[:idx]
 
 
+def resolve_premium_model(model: str) -> str:
+    """Resolve a stable/legacy selector to an allowed current provider model."""
+    resolved = PREMIUM_MODEL_PROFILES.get(model, LEGACY_MODEL_ALIASES.get(model, model))
+    if resolved not in ALLOWED_PREMIUM_MODELS:
+        raise ValueError(f"Unsupported writing model: {model}")
+    return resolved
+
+
 def llm_chat_premium(
     system_prompt: str,
     user_prompt: str,
-    model: str = "Meta-Llama-3.1-405B-Instruct",
+    model: str = "gpt-oss-120b",
     temperature: float = 0.7,
     max_tokens: int = 4096,
 ) -> tuple[str, str]:
-    """Call a premium model via GitHub Models API.
+    """Call an allowed premium model through Groq.
 
-    Returns (content, model_used).  Falls back to the standard Groq/HF cascade
-    if GitHub PAT is not configured or if the call fails.
+    Returns (content, model_used). Falls back to the standard Groq/HF cascade
+    when the selected model is unavailable or its free-tier limit is reached.
     """
     messages = [
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": user_prompt},
     ]
 
-    pat = settings.github_pat
-    if pat:
-        logger.info(
-            "Attempting GitHub Models: model=%s, PAT prefix=%s..., url=%s",
-            model, pat[:10], GITHUB_MODELS_URL,
-        )
-        try:
-            content = _call_provider(
-                url=GITHUB_MODELS_URL,
-                api_key=pat,
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                timeout=90.0,
-            )
-            logger.info("GitHub Models (%s) succeeded.", model)
-            return content, model
-        except ProviderError as e:
-            logger.error("GitHub Models (%s) FAILED: %s — falling back to standard.", model, e)
+    resolved_model = resolve_premium_model(model)
+    if _groq_keys:
+        with _groq_lock:
+            start_key = next(_groq_cycle)  # type: ignore[arg-type]
+        for index, key in enumerate(_rotate_from(start_key)):
+            try:
+                content = _call_provider(
+                    url=GROQ_URL,
+                    api_key=key,
+                    model=resolved_model,
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=60.0,
+                )
+                logger.info("Groq premium model %s succeeded.", resolved_model)
+                return content, resolved_model
+            except ProviderError as exc:
+                logger.warning(
+                    "Groq premium key %d/%d failed for %s: %s",
+                    index + 1,
+                    len(_groq_keys),
+                    resolved_model,
+                    exc,
+                )
     else:
-        logger.warning("GITHUB_PAT not set — skipping premium, using standard cascade.")
+        logger.warning("No Groq key configured — using the standard fallback cascade.")
 
     # Fallback: use the standard Groq -> HF cascade
     content = llm_chat_messages(messages, temperature=temperature, max_tokens=max_tokens)

services/paraphrase_service.py

@@ -2,7 +2,7 @@
 Paraphrase service.
 
 Uses LLM (Groq / HF Inference) when available; falls back to local T5 model.
-Premium mode uses GitHub Models (Meta-Llama-3.1-405B-Instruct).
+Premium mode uses the current Groq-hosted Anovo model profiles.
 """
 from __future__ import annotations
 
@@ -72,10 +72,10 @@ def paraphrase(text: str, intensity: int = 3, writing_mode: str = "standard") ->
 def paraphrase_premium(
     text: str,
     intensity: int = 3,
-    model: str = "Meta-Llama-3.1-405B-Instruct",
+    model: str = "gpt-oss-120b",
     writing_mode: str = "standard",
 ) -> tuple[str, str]:
-    """Paraphrase using a premium GitHub Models model. Returns (text, model_used)."""
+    """Paraphrase using a premium writing model. Returns (text, model_used)."""
     try:
         return _paraphrase_llm_premium(text, intensity, model, writing_mode)
     except RuntimeError:

tests/test_api.py

@@ -6,6 +6,7 @@ All service calls are mocked so no ML models or external services are required.
 import sys
 import os
 from unittest.mock import patch
+from unittest.mock import MagicMock
 from fastapi.testclient import TestClient
 
 # Ensure the backend directory is on the path when running from backend/
@@ -16,6 +17,19 @@ from main import app  # noqa: E402
 client = TestClient(app)
 
 
+class TestAccountDeletion:
+    def test_delete_account_removes_user_and_commits(self):
+        from routers.auth import delete_me
+
+        db = MagicMock()
+        user = MagicMock()
+        with patch("routers.auth.get_user_by_id", return_value=user):
+            delete_me(user_id=42, db=db)
+
+        db.delete.assert_called_once_with(user)
+        db.commit.assert_called_once_with()
+
+
 # ── Health ────────────────────────────────────────────────────────────────────
 
 class TestHealth:

tests/test_llm_client.py

@@ -0,0 +1,25 @@
+"""Tests for the current writing-model registry and legacy migrations."""
+
+import pytest
+
+from services.llm_client import resolve_premium_model
+
+
+@pytest.mark.parametrize(
+    ("selector", "expected"),
+    [
+        ("gpt-oss-120b", "openai/gpt-oss-120b"),
+        ("gpt-oss-20b", "openai/gpt-oss-20b"),
+        ("qwen-3.6-27b", "qwen/qwen3.6-27b"),
+        ("gpt-4o", "openai/gpt-oss-120b"),
+        ("gpt-4o-mini", "openai/gpt-oss-20b"),
+        ("Meta-Llama-3.1-405B-Instruct", "openai/gpt-oss-120b"),
+    ],
+)
+def test_resolve_premium_model(selector, expected):
+    assert resolve_premium_model(selector) == expected
+
+
+def test_resolve_premium_model_rejects_arbitrary_provider_ids():
+    with pytest.raises(ValueError, match="Unsupported writing model"):
+        resolve_premium_model("unknown/provider-model")