fix: update tier mode

app.py

@@ -246,7 +246,8 @@ async def chat(req: ChatRequest):
     use_deepmind     = req.use_deepmind and deepmind_allowed
 
     if use_deepmind:
-        dm_ok, dm_msg = check_deepmind_limit(req.user_id)
+        submode = req.deepmind_submode or "pro"
+        dm_ok, dm_msg = check_deepmind_limit(req.user_id, submode)
         if not dm_ok:
             raise HTTPException(status_code=429, detail=dm_msg)
 
@@ -299,13 +300,14 @@ async def chat(req: ChatRequest):
 
     # Save user message (primary doc_id for legacy compatibility)
     supa.table("chat_history").insert({
-        "doc_id":      req.doc_id,
-        "session_id":  req.session_id,
-        "user_id":     req.user_id,
-        "role":        "user",
-        "content":     req.query,
-        "expires_at":  expires.isoformat(),
-        "is_deepmind": use_deepmind,
+        "doc_id":            req.doc_id,
+        "session_id":        req.session_id,
+        "user_id":           req.user_id,
+        "role":              "user",
+        "content":           req.query,
+        "expires_at":        expires.isoformat(),
+        "is_deepmind":       use_deepmind,
+        "deepmind_submode":  (req.deepmind_submode or "pro") if use_deepmind else None,
     }).execute()
 
     def generate():
@@ -328,13 +330,14 @@ async def chat(req: ChatRequest):
 
         # Persist assistant response
         supa.table("chat_history").insert({
-            "doc_id":      req.doc_id,
-            "session_id":  req.session_id,
-            "user_id":     req.user_id,
-            "role":        "assistant",
-            "content":     "".join(full_resp),
-            "expires_at":  expires.isoformat(),
-            "is_deepmind": use_deepmind,
+            "doc_id":            req.doc_id,
+            "session_id":        req.session_id,
+            "user_id":           req.user_id,
+            "role":              "assistant",
+            "content":           "".join(full_resp),
+            "expires_at":        expires.isoformat(),
+            "is_deepmind":       use_deepmind,
+            "deepmind_submode":  (req.deepmind_submode or "pro") if use_deepmind else None,
         }).execute()
         yield "data: [DONE]\n\n"
 

persistence/tier.py

@@ -26,11 +26,19 @@ DOC_LIMIT: dict[Tier, int | None] = {Tier.FREE: 1,  Tier.PRO: 10, Tier.SCHOLAR:
 # General message limits (per session for FREE, per day for paid)
 MSG_LIMIT: dict[Tier, int | None] = {Tier.FREE: 5,  Tier.PRO: 200, Tier.SCHOLAR: None}
 
-# DeepMind (Groq) daily message limits — separate quota from general messages
-DEEPMIND_LIMIT: dict[Tier, int | None] = {
-    Tier.FREE:    5,    # Free users get 5 DeepMind messages/day
-    Tier.PRO:     200,  # Pro users get 200 DeepMind messages/day
-    Tier.SCHOLAR: 500,  # Scholar users get 500 DeepMind messages/day
+# DeepMind daily message limits — split by submode.
+# "pro"   submode = Groq-powered (fast, context-limited)
+# "super" submode = Cerebras-powered (ultra-fast, full-context)
+DEEPMIND_PRO_LIMIT: dict[Tier, int | None] = {
+    Tier.FREE:    5,    # 5 Pro messages/day
+    Tier.PRO:     100,  # 100 Pro messages/day
+    Tier.SCHOLAR: 300,  # 300 Pro messages/day
+}
+
+DEEPMIND_SUPER_LIMIT: dict[Tier, int | None] = {
+    Tier.FREE:    2,    # 2 Super messages/day (Free users)
+    Tier.PRO:     50,   # 50 Super messages/day
+    Tier.SCHOLAR: 200,  # 200 Super messages/day
 }
 
 
@@ -111,14 +119,15 @@ def check_message_limit(user_id: str, session_id: str) -> tuple[bool, str]:
     return True, "ok"
 
 
-def check_deepmind_limit(user_id: str) -> tuple[bool, str]:
-    """Check the user's DeepMind (Groq) daily message limit.
+def check_deepmind_limit(user_id: str, submode: str = "pro") -> tuple[bool, str]:
+    """Check the user's DeepMind daily limit for the given submode.
 
-    DeepMind messages are tracked via the is_deepmind flag on chat_history rows.
-    Limits: Free=5/day, Pro=200/day, Scholar=500/day (all per UTC calendar day).
+    Submode 'pro'   → Groq-powered   — limits: Free=5,  Pro=100, Scholar=300
+    Submode 'super' → Cerebras-powered — limits: Free=2, Pro=50,  Scholar=200
+    All counts are per UTC calendar day.
     """
     tier  = get_user_tier(user_id)
-    limit = DEEPMIND_LIMIT[tier]
+    limit = (DEEPMIND_SUPER_LIMIT if submode == "super" else DEEPMIND_PRO_LIMIT)[tier]
     if limit is None:
         return True, "ok"
 
@@ -130,41 +139,65 @@ def check_deepmind_limit(user_id: str) -> tuple[bool, str]:
         .eq("user_id", user_id)
         .eq("role", "user")
         .eq("is_deepmind", True)
+        .eq("deepmind_submode", submode)
         .gte("created_at", today)
         .execute()
         .count
-    )
+    ) or 0
 
     if count >= limit:
-        tier_label = tier.capitalize()
+        tier_label  = tier.capitalize()
+        mode_label  = "Super" if submode == "super" else "Pro"
         return False, (
-            f"DeepMind daily limit reached ({limit} messages/day on {tier_label} plan). "
+            f"DeepMind {mode_label} daily limit reached ({limit} messages/day on {tier_label} plan). "
             "Resets at midnight UTC."
         )
     return True, "ok"
 
 
 def get_deepmind_usage(user_id: str) -> dict:
-    """Return DeepMind usage stats for today: {used, limit, remaining}."""
-    tier  = get_user_tier(user_id)
-    limit = DEEPMIND_LIMIT[tier]
+    """Return per-submode DeepMind usage stats for today.
+
+    Returns:
+        {
+            tier: str,
+            pro:   { used, limit, remaining },
+            super: { used, limit, remaining },
+        }
+    """
+    tier   = get_user_tier(user_id)
+    client = _client()
+    today  = datetime.now(UTC).date().isoformat()
 
-    today = datetime.now(UTC).date().isoformat()
-    used = (
-        _client()
-        .table("chat_history")
-        .select("id", count="exact")
-        .eq("user_id", user_id)
-        .eq("role", "user")
-        .eq("is_deepmind", True)
-        .gte("created_at", today)
-        .execute()
-        .count
-    ) or 0
+    def _count(submode: str) -> int:
+        return (
+            client
+            .table("chat_history")
+            .select("id", count="exact")
+            .eq("user_id", user_id)
+            .eq("role", "user")
+            .eq("is_deepmind", True)
+            .eq("deepmind_submode", submode)
+            .gte("created_at", today)
+            .execute()
+            .count
+        ) or 0
+
+    pro_used   = _count("pro")
+    super_used = _count("super")
+    pro_limit  = DEEPMIND_PRO_LIMIT[tier]
+    sup_limit  = DEEPMIND_SUPER_LIMIT[tier]
 
     return {
-        "used":      used,
-        "limit":     limit,
-        "remaining": (limit - used) if limit is not None else None,
-        "tier":      str(tier),
+        "tier": str(tier),
+        "pro": {
+            "used":      pro_used,
+            "limit":     pro_limit,
+            "remaining": (pro_limit - pro_used) if pro_limit is not None else None,
+        },
+        "super": {
+            "used":      super_used,
+            "limit":     sup_limit,
+            "remaining": (sup_limit - super_used) if sup_limit is not None else None,
+        },
     }