app/services/input_guard.py

import re
from app.models.deberta_model import classifier
from app.services.rules_manager import rules_manager

def validate_input(prompt: str) -> dict:
    """
    Validates input prompt against dynamic regex rules and semantic DeBERTa model.
    """
    # 1. Check Regex Rules
    for rule in rules_manager.jailbreak_rules:
        pattern = rule.get("pattern", "")
        if pattern and re.search(pattern, prompt):
            return {
                "safe": False,
                "risk_score": 1.0,
                "category": "jailbreak",
                "matched_rule": rule.get("name", "unknown")
            }

    # 2. Check Semantic Vector Similarity
    if rules_manager.semantic_enabled:
        from app.services.semantic_guard import semantic_guard
        # Ensure semantic guard is initialized
        if not semantic_guard.initialized:
            semantic_guard.initialize()
            
        sim_score, matched_phrase = semantic_guard.check_similarity(prompt)
        if sim_score >= rules_manager.semantic_threshold:
            return {
                "safe": False,
                "risk_score": float(sim_score),
                "category": "semantic_similarity",
                "matched_rule": f"semantic_match: {matched_phrase}"
            }

    # 3. Check DeBERTa Semantic Classifier
    try:
        model_result = classifier.predict(prompt)
        
        # Detect benign coding/programming requests to bypass DeBERTa false positives
        is_coding_request = bool(re.search(
            r"(?i)\b(python|javascript|java|c\+\+|c#|html|css|php|sql|bash|program|script|code|calculator|write\s+a\s+program|create\s+a\s+program)\b",
            prompt
        ))
        
        # Detect benign greetings / introductions to bypass DeBERTa false positives
        is_benign_greeting = bool(re.match(
            r"(?i)^\s*(hello|hi|hey|greetings|good\s+morning|good\s+afternoon|good\s+evening|howdy)?[,\s]*(i\s+am|my\s+name\s+is|this\s+is|call\s+me)?\s*[a-zA-Z0-9_-]+[,\s]*(remember\s+it|remember\s+this|who\s+are\s+you|how\s+are\s+you)?[.!?\s]*$",
            prompt
        ))

        # Detect mathematical expressions
        is_math = bool(re.match(r"^\s*[\d\s+\-*/%^()=.]+\s*$", prompt))

        # Detect long repetitive gibberish/random strings (e.g. repeating characters)
        clean_prompt = prompt.strip().lower()
        is_repetitive = len(clean_prompt) > 20 and len(set(clean_prompt.replace(" ", ""))) <= 4
        
        if not model_result["safe"] and (is_coding_request or is_benign_greeting or is_math or is_repetitive):
            return {
                "safe": True,
                "risk_score": model_result["risk_score"],
                "category": "safe",
                "matched_rule": "none (bypassed false-positive)"
            }
            
        return {
            "safe": model_result["safe"],
            "risk_score": model_result["risk_score"],
            "category": model_result["category"],
            "matched_rule": "none"
        }
    except Exception as e:
        return {
            "safe": True,
            "risk_score": 0.0,
            "category": "safe",
            "matched_rule": f"error: {str(e)}"
        }