v4.3: pre-filter layer — zero API cost spam defense

Three defense lines BEFORE AI:
1. Repeat detection (already had) — same msg 3x in 5min
2. Pre-filter (NEW):
- Keyword/regex: multilingual spam patterns + URL/contact combo
- Forward spam: forwarded msg with link/contact = spam
- New account: no username + no name + has link = spam
3. API rate limiter with token bucket:
- 50 calls/minute budget
- Below 20%: sampling mode (1 in 3 messages)
- Exhausted: rules-only mode, no AI calls
- Graceful degradation, never goes blind

AI only sees messages that pass all pre-filters.
Addresses ACC red team finding #2 (rate limit trap).

bot.py

@@ -23,6 +23,7 @@ from modules.chat import (
     GROUP_WELCOME
 )
 from modules.admin import is_admin, is_bot_admin, register_group
+from modules.prefilter import prefilter
 
 logging.basicConfig(
     format="%(asctime)s [%(levelname)s] %(message)s",
@@ -231,36 +232,42 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
             spam = True
             logger.info("REPEAT SPAM: user=" + str(uid) + " chat=" + str(chat_id) + " count=" + str(len(recent_same)))
 
-    # AI spam check (skip if already caught)
+    # Pre-filter: keyword/regex/forward/new-account (zero API cost)
     if not spam:
-        if msg.photo:
-            try:
-                f = await context.bot.get_file(msg.photo[-1].file_id)
-                data = bytes(await f.download_as_bytearray())
-                spam = await ai_judge_group_image(data, text)
-            except Exception:
-                if text:
-                    spam = await ai_judge_group_message(text)
-        elif msg.video:
-            if msg.video.thumbnail:
+        verdict = prefilter(msg, user, text)
+        if verdict == "spam":
+            spam = True
+        elif verdict == "ai":
+            # Needs AI analysis (API budget available)
+            if msg.photo:
                 try:
-                    vf = await context.bot.get_file(msg.video.thumbnail.file_id)
-                    vdata = bytes(await vf.download_as_bytearray())
-                    spam = await ai_judge_group_image(vdata, text)
+                    f = await context.bot.get_file(msg.photo[-1].file_id)
+                    data = bytes(await f.download_as_bytearray())
+                    spam = await ai_judge_group_image(data, text)
                 except Exception:
                     if text:
                         spam = await ai_judge_group_message(text)
+            elif msg.video:
+                if msg.video.thumbnail:
+                    try:
+                        vf = await context.bot.get_file(msg.video.thumbnail.file_id)
+                        vdata = bytes(await vf.download_as_bytearray())
+                        spam = await ai_judge_group_image(vdata, text)
+                    except Exception:
+                        if text:
+                            spam = await ai_judge_group_message(text)
+                elif text:
+                    spam = await ai_judge_group_message(text)
+                elif msg.forward_date:
+                    spam = True
+            elif msg.document or msg.sticker:
+                if text:
+                    spam = await ai_judge_group_message(text)
+                elif msg.forward_date:
+                    spam = True
             elif text:
                 spam = await ai_judge_group_message(text)
-            elif msg.forward_date:
-                spam = True
-        elif msg.document or msg.sticker:
-            if text:
-                spam = await ai_judge_group_message(text)
-            elif msg.forward_date:
-                spam = True
-        elif text:
-            spam = await ai_judge_group_message(text)
+        # verdict == "clean" → skip AI, let it through
 
     if spam:
         try:

modules/prefilter.py

@@ -0,0 +1,170 @@
+"""
+Pre-filter: catches obvious spam BEFORE burning an AI API call.
+Zero cost. Runs on every message. AI only sees what passes all filters.
+"""
+
+import re
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Spam keyword patterns (multilingual)
+SPAM_KEYWORDS = re.compile(
+    r'加[我微v]|私聊领|免费领|日[赚入]|月入[过百千万]|'
+    r'代[开做理]|招[代聘]|兼\s*职|刷\s*单|'
+    r'翻[几十百]倍|稳赚|保本|零风险|'
+    r'[\U0001F4B0\U0001F4B8\U0001F911]{2,}|'  # money emoji spam
+    r'click here|earn money|work from home|make \$|'
+    r'free crypto|airdrop|whitelist spot|'
+    r'join (?:my|our|this) (?:channel|group)|'
+    r't\.me/(?:joinchat|[+])',
+    re.IGNORECASE
+)
+
+# URL patterns
+URL_PATTERN = re.compile(
+    r'https?://|t\.me/|bit\.ly|tinyurl|wa\.me|'
+    r'@\w+bot\b',
+    re.IGNORECASE
+)
+
+# Contact info patterns
+CONTACT_PATTERN = re.compile(
+    r'[\U0001F4DE\U0001F4F1]|'  # phone emojis
+    r'(?:whatsapp|telegram|wechat|微信|qq)\s*[:：]?\s*\d|'
+    r'(?:加|add)\s*(?:我|me)',
+    re.IGNORECASE
+)
+
+
+class APIRateLimiter:
+    """Token bucket rate limiter for AI API calls."""
+
+    def __init__(self, max_calls=50, window=60):
+        self.max_calls = max_calls  # max calls per window
+        self.window = window        # window in seconds
+        self.calls = []             # timestamps of recent calls
+
+    def can_call(self):
+        """Check if we can make another API call."""
+        now = time.time()
+        self.calls = [t for t in self.calls if now - t < self.window]
+        return len(self.calls) < self.max_calls
+
+    def record_call(self):
+        """Record an API call."""
+        self.calls.append(time.time())
+
+    def remaining(self):
+        """How many calls left in current window."""
+        now = time.time()
+        self.calls = [t for t in self.calls if now - t < self.window]
+        return max(0, self.max_calls - len(self.calls))
+
+    def is_critical(self):
+        """Below 20% budget — switch to sampling mode."""
+        return self.remaining() < self.max_calls * 0.2
+
+
+# Global rate limiter: 50 AI calls per minute (adjustable)
+api_limiter = APIRateLimiter(max_calls=50, window=60)
+
+
+def keyword_spam(text):
+    """Fast keyword check. Returns True if obvious spam."""
+    if not text:
+        return False
+    # Keyword match + has URL or contact = almost certainly spam
+    has_keywords = bool(SPAM_KEYWORDS.search(text))
+    has_url = bool(URL_PATTERN.search(text))
+    has_contact = bool(CONTACT_PATTERN.search(text))
+
+    if has_keywords and (has_url or has_contact):
+        return True
+
+    # Pure contact harvesting: just a contact method, no real conversation
+    if has_contact and len(text) < 100 and not any(c in text for c in '?？'):
+        return True
+
+    return False
+
+
+def forward_spam(msg):
+    """Forwarded message with link/contact = spam."""
+    if not msg.forward_date:
+        return False
+    text = msg.text or msg.caption or ""
+    if URL_PATTERN.search(text) or CONTACT_PATTERN.search(text):
+        return True
+    # Forwarded media with no caption from non-group member = suspicious
+    if not text and (msg.photo or msg.video or msg.document):
+        return True
+    return False
+
+
+def new_account_spam(user, text):
+    """New/suspicious accounts with links = spam."""
+    if not text or not URL_PATTERN.search(text):
+        return False
+    # No username + no profile photo + has link = high spam probability
+    suspicious = 0
+    if not user.username:
+        suspicious += 1
+    if not user.first_name or len(user.first_name) < 2:
+        suspicious += 1
+    # Name is just emojis or special chars
+    if user.first_name and not any(c.isalpha() for c in user.first_name):
+        suspicious += 1
+    return suspicious >= 2
+
+
+def should_use_ai(msg):
+    """Decide if this message needs AI analysis or if we should skip/sample."""
+    if not api_limiter.can_call():
+        logger.warning("API rate limit hit — falling back to rules only")
+        return False
+
+    if api_limiter.is_critical():
+        # Sampling mode: only check 1 in 3 messages
+        import random
+        if random.random() > 0.33:
+            logger.info("API budget critical — sampling mode, skipping this message")
+            return False
+
+    return True
+
+
+def prefilter(msg, user, text):
+    """
+    Run all pre-filters. Returns:
+      "spam"  — definitely spam, skip AI, nuke immediately
+      "clean" — definitely clean, skip AI
+      "ai"    — unclear, needs AI analysis
+    """
+    # Layer 1: Forward spam (zero false positive)
+    if forward_spam(msg):
+        logger.info("PREFILTER forward_spam: user=" + str(user.id))
+        return "spam"
+
+    # Layer 2: Keyword + link/contact (very high accuracy)
+    if text and keyword_spam(text):
+        logger.info("PREFILTER keyword_spam: user=" + str(user.id) + " text=" + text[:50])
+        return "spam"
+
+    # Layer 3: Suspicious new account + link
+    if new_account_spam(user, text):
+        logger.info("PREFILTER new_account_spam: user=" + str(user.id))
+        return "spam"
+
+    # Layer 4: No text, no media = nothing to check
+    if not text and not msg.photo and not msg.video:
+        return "clean"
+
+    # Layer 5: Rate limiter — can we afford an AI call?
+    if not should_use_ai(msg):
+        return "clean"  # let it through rather than false-positive
+
+    # Needs AI
+    api_limiter.record_call()
+    return "ai"