Merge remote-tracking branch 'origin/main' into ishaan-jaffer/insults-eval

# Conflicts:
#	ui/litellm-dashboard/src/data/compliancePrompts.ts

litellm/proxy/_new_secret_config.yaml

@@ -24,6 +24,33 @@ guardrails:
       guardrail: mcp_end_user_permission
       mode: pre_call
       default_on: true
+  - guardrail_name: "airline-competitor-intent"
+    guardrail_id: "airline-competitor-intent"
+    litellm_params:
+      guardrail: litellm_content_filter
+      mode: pre_call
+      default_on: false
+      competitor_intent_config:
+        brand_self:
+          - emirates
+          - ek
+        competitors:
+          - qatar airways
+          - qatar
+          - etihad
+        locations:
+          - qatar
+          - doha
+          - doh
+        competitor_aliases:
+          qatar airways: [qr, doha airline]
+          qatar: [qr]
+        policy:
+          competitor_comparison: refuse
+          possible_competitor_comparison: reframe
+        threshold_high: 0.70
+        threshold_medium: 0.45
+        threshold_low: 0.30
 
 mcp_servers:
   my_http_server:

litellm/proxy/auth/auth_checks.py

@@ -41,11 +41,11 @@ from litellm.proxy._types import (
     LiteLLM_ObjectPermissionTable,
     LiteLLM_OrganizationMembershipTable,
     LiteLLM_OrganizationTable,
+    LiteLLM_ProjectTableCachedObj,
     LiteLLM_TagTable,
     LiteLLM_TeamMembership,
     LiteLLM_TeamTable,
     LiteLLM_TeamTableCachedObj,
-    LiteLLM_ProjectTableCachedObj,
     LiteLLM_UserTable,
     LiteLLMRoutes,
     LitellmUserRoles,
@@ -57,6 +57,7 @@ from litellm.proxy._types import (
     UserAPIKeyAuth,
 )
 from litellm.proxy.auth.route_checks import RouteChecks
+from litellm.proxy.db.exception_handler import PrismaDBExceptionHandler
 from litellm.proxy.route_llm_request import route_request
 from litellm.proxy.utils import PrismaClient, ProxyLogging, log_db_metrics
 from litellm.router import Router
@@ -1982,6 +1983,51 @@ class ExperimentalUIJWTToken:
             )
 
 
+async def _fetch_key_object_from_db_with_reconnect(
+    hashed_token: str,
+    prisma_client: PrismaClient,
+    parent_otel_span: Optional[Span],
+    proxy_logging_obj: Optional[ProxyLogging],
+) -> Optional[BaseModel]:
+    """
+    Fetch key object from DB and retry once if a DB connection error can be healed.
+    """
+    try:
+        return await prisma_client.get_data(
+            token=hashed_token,
+            table_name="combined_view",
+            parent_otel_span=parent_otel_span,
+            proxy_logging_obj=proxy_logging_obj,
+        )
+    except Exception as e:
+        if PrismaDBExceptionHandler.is_database_connection_error(e):
+            did_reconnect = False
+            if hasattr(prisma_client, "attempt_db_reconnect"):
+                auth_reconnect_timeout = getattr(
+                    prisma_client, "_db_auth_reconnect_timeout_seconds", 2.0
+                )
+                if not isinstance(auth_reconnect_timeout, (int, float)):
+                    auth_reconnect_timeout = 2.0
+                auth_reconnect_lock_timeout = getattr(
+                    prisma_client, "_db_auth_reconnect_lock_timeout_seconds", 0.1
+                )
+                if not isinstance(auth_reconnect_lock_timeout, (int, float)):
+                    auth_reconnect_lock_timeout = 0.1
+                did_reconnect = await prisma_client.attempt_db_reconnect(
+                    reason="auth_get_key_object_lookup_failure",
+                    timeout_seconds=auth_reconnect_timeout,
+                    lock_timeout_seconds=auth_reconnect_lock_timeout,
+                )
+            if did_reconnect:
+                return await prisma_client.get_data(
+                    token=hashed_token,
+                    table_name="combined_view",
+                    parent_otel_span=parent_otel_span,
+                    proxy_logging_obj=proxy_logging_obj,
+                )
+        raise
+
+
 @log_db_metrics
 async def get_key_object(
     hashed_token: str,
@@ -2020,11 +2066,13 @@ async def get_key_object(
         )
 
     # else, check db
-    _valid_token: Optional[BaseModel] = await prisma_client.get_data(
-        token=hashed_token,
-        table_name="combined_view",
-        parent_otel_span=parent_otel_span,
-        proxy_logging_obj=proxy_logging_obj,
+    _valid_token: Optional[BaseModel] = (
+        await _fetch_key_object_from_db_with_reconnect(
+            hashed_token=hashed_token,
+            prisma_client=prisma_client,
+            parent_otel_span=parent_otel_span,
+            proxy_logging_obj=proxy_logging_obj,
+        )
     )
 
     if _valid_token is None:

litellm/proxy/db/exception_handler.py

@@ -38,8 +38,30 @@ class PrismaDBExceptionHandler:
 
         if isinstance(e, DB_CONNECTION_ERROR_TYPES):
             return True
-        if isinstance(e, prisma.errors.PrismaError):
+        if isinstance(
+            e, (prisma.errors.ClientNotConnectedError, prisma.errors.HTTPClientClosedError)
+        ):
             return True
+        if isinstance(e, prisma.errors.PrismaError):
+            error_message = str(e).lower()
+            # Treat generic PrismaError as connection error only when its text
+            # clearly indicates transport/connectivity failure.
+            connection_keywords = (
+                "can't reach database server",
+                "cannot reach database server",
+                "can't connect",
+                "cannot connect",
+                "connection error",
+                "connection closed",
+                "timed out",
+                "timeout",
+                "connection refused",
+                "network is unreachable",
+                "no route to host",
+                "broken pipe",
+            )
+            if any(keyword in error_message for keyword in connection_keywords):
+                return True
         if isinstance(e, ProxyException) and e.type == ProxyErrorTypes.no_db_connection:
             return True
         return False

litellm/proxy/guardrails/guardrail_endpoints.py

@@ -827,6 +827,42 @@ async def get_category_yaml(category_name: str):
         )
 
 
+@router.get(
+    "/guardrails/ui/major_airlines",
+    tags=["Guardrails"],
+    dependencies=[Depends(user_api_key_auth)],
+)
+async def get_major_airlines():
+    """
+    Get the major airlines list from IATA (competitor intent, airline type).
+    Returns airline id, match variants (pipe-separated), and tags.
+    """
+    import os
+
+    airlines_path = os.path.join(
+        os.path.dirname(__file__),
+        "guardrail_hooks",
+        "litellm_content_filter",
+        "competitor_intent",
+        "major_airlines.json",
+    )
+    if not os.path.exists(airlines_path):
+        raise HTTPException(
+            status_code=404,
+            detail="major_airlines.json not found",
+        )
+    try:
+        with open(airlines_path, "r", encoding="utf-8") as f:
+            import json
+
+            airlines = json.load(f)
+        return {"airlines": airlines}
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Error reading major_airlines.json: {str(e)}"
+        ) from e
+
+
 @router.post(
     "/guardrails/validate_blocked_words_file",
     tags=["Guardrails"],

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/__init__.py

@@ -1,9 +1,8 @@
 from typing import TYPE_CHECKING, Optional
 
 import litellm
-from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import (
-    ContentFilterGuardrail,
-)
+from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import \
+    ContentFilterGuardrail
 from litellm.types.guardrails import SupportedGuardrailIntegrations
 
 if TYPE_CHECKING:
@@ -44,6 +43,9 @@ def initialize_guardrail(
         severity_threshold=getattr(litellm_params, "severity_threshold", "medium"),
         llm_router=llm_router,
         image_model=getattr(litellm_params, "image_model", None),
+        competitor_intent_config=getattr(
+            litellm_params, "competitor_intent_config", None
+        ),
     )
 
     litellm.logging_callback_manager.add_litellm_callback(content_filter_guardrail)

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/competitor_intent/__init__.py

@@ -0,0 +1,17 @@
+"""
+Competitor intent: entity + intent disambiguation with safe (non-competitor) defaults.
+
+Base logic in base.py; industry-specific checkers in submodules (e.g. airline.py).
+"""
+
+from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.competitor_intent.airline import \
+    AirlineCompetitorIntentChecker
+from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.competitor_intent.base import (
+    BaseCompetitorIntentChecker, normalize, text_for_entity_matching)
+
+__all__ = [
+    "BaseCompetitorIntentChecker",
+    "AirlineCompetitorIntentChecker",
+    "normalize",
+    "text_for_entity_matching",
+]

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/competitor_intent/airline.py

@@ -0,0 +1,211 @@
+"""
+Airline-specific competitor intent: other meaning (e.g. location/travel context) vs competitor airline.
+
+Uses context-based disambiguation only: no hardcoded place lists. Detects travel-location
+language (prepositions, travel verbs, booking/entry nouns) vs airline context (airways,
+carrier, lounge, miles, etc.) and scores to decide OTHER_MEANING vs COMPETITOR.
+
+When competitors is not provided, loads major_airlines.json and excludes the customer's
+brand_self so all other major airlines are treated as competitors.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.competitor_intent.base import (
+    BaseCompetitorIntentChecker, _compile_marker, _count_signals,
+    _word_boundary_match)
+
+# Location/travel context: prepositions, travel verbs, booking nouns, entry/geo nouns.
+# No place-name list; these patterns detect "destination context" generically.
+AIRLINE_OTHER_MEANING_SIGNALS = [
+    # Travel verb + preposition (e.g. "fly to", "layover in")
+    r"\b(fly|flying|travel|traveling|going|visit|visiting|transit|layover|stopover)\b.{0,12}\b(to|from|via|in|at|through|into)\b",
+    # Booking + preposition
+    r"\bflight(s)?\b.{0,10}\b(to|from|via)\b",
+    r"\bticket(s)?\b.{0,8}\b(to|for)\b",
+    r"\bfare(s)?\b.{0,8}\b(to)\b",
+    # Entry/geo/booking single words
+    r"\bvisa\b",
+    r"\bimmigration\b",
+    r"\bcustoms\b",
+    r"\bentry\b",
+    r"\bairport\b",
+    r"\bterminal\b",
+    r"\bgate\b",
+    r"\bdeparture\b",
+    r"\barrival\b",
+    r"\bitinerary\b",
+    r"\bweather\b",
+    r"\bhotel\b",
+    r"\bcity\b",
+    # Prepositions alone (weaker; often near a place)
+    r"\bto\s+",
+    r"\bfrom\s+",
+    r"\bin\s+",
+    r"\bat\s+",
+    r"\bvia\s+",
+]
+
+# Airline context: carrier/airline language, cabin, loyalty, operations.
+# If ambiguous token appears near these → treat as COMPETITOR.
+AIRLINE_COMPETITOR_SIGNALS = [
+    r"\bairways?\b",
+    r"\bairline\b",
+    r"\bcarrier\b",
+    r"\bcabin\s+crew\b",
+    r"\bflight\s+attendant\b",
+    r"\bbusiness\s+class\b",
+    r"\bfirst\s+class\b",
+    r"\beconomy\b",
+    r"\blounge\b",
+    r"\bbaggage\s+allowance\b",
+    r"\bcheck[- ]?in\b",
+    r"\bmiles\b",
+    r"\bloyalty\b",
+    r"\bstatus\b",
+    r"\bfrequent\s+flyer\b",
+    r"\bfleet\b",
+    r"\baircraft\b",
+    # Comparison/ranking
+    r"\bbetter\b",
+    r"\bbest\b",
+    r"\bgood\b",
+    r"\bas\s+good\s+as\b",
+    r"\bvs\.?\b",
+    r"\bversus\b",
+    r"\bcompare\b",
+    r"\balternative\b",
+    r"\bcompetitor\b",
+    # Brand-specific (optional; config can extend)
+    r"\bqmiles\b",
+    r"\bprivilege\s+club\b",
+]
+
+# Operational-only: baggage, lounge, check-in, refund (no comparison language).
+# When only these appear with ambiguous token → treat as product query (OTHER_MEANING).
+AIRLINE_OPERATIONAL_SIGNALS = [
+    r"\bbaggage\s+allowance\b",
+    r"\blounge\b",
+    r"\bcheck[- ]?in\b",
+    r"\brefund\b",
+    r"\bpremium\s+lounge\b",
+]
+# Comparison language: if present with competitor signals → COMPETITOR.
+AIRLINE_COMPARISON_SIGNALS = [
+    r"\bbetter\b",
+    r"\bbest\b",
+    r"\bvs\.?\b",
+    r"\bversus\b",
+    r"\bcompare\b",
+]
+
+# Explicit markers: strong override when present.
+AIRLINE_EXPLICIT_COMPETITOR_MARKER = r"\b(airways?|airline|carrier)\b"
+AIRLINE_EXPLICIT_OTHER_MEANING_MARKER = (
+    r"\b(fly|travel|going|visit|layover|stopover|transit)\b.{0,12}\b(to|in|via|from)\b.{0,8}\b"
+)
+
+_MAJOR_AIRLINES_PATH = (
+    Path(__file__).resolve().parent / "major_airlines.json"
+)
+
+
+def _load_competitors_excluding_brand(brand_self: List[str]) -> List[str]:
+    """
+    Load competitor tokens from major_airlines.json (harm_toxic_abuse-style format).
+    Exclude any airline whose id or match variants overlap with brand_self.
+    Returns a flat list of match variants (pipe-separated values) from non-excluded airlines.
+    """
+    brand_set = {b.lower().strip() for b in brand_self if b}
+    if not _MAJOR_AIRLINES_PATH.exists():
+        return []
+    try:
+        with open(_MAJOR_AIRLINES_PATH, encoding="utf-8") as f:
+            airlines = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return []
+    result: List[str] = []
+    for entry in airlines:
+        if not isinstance(entry, dict):
+            continue
+        match_str = entry.get("match") or ""
+        variants = [v.strip().lower() for v in match_str.split("|") if v.strip()]
+        words_in_match = set()
+        for v in variants:
+            words_in_match.update(v.split())
+        if brand_set & words_in_match or any(v in brand_set for v in variants):
+            continue
+        result.extend(variants)
+    return result
+
+
+class AirlineCompetitorIntentChecker(BaseCompetitorIntentChecker):
+    """
+    Disambiguates other meaning (e.g. country/city/airport) vs competitor airline
+    (e.g. "Qatar" → country vs Qatar Airways). Overrides _classify_ambiguous
+    with other_meaning/competitor signals and explicit markers.
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        merged: Dict[str, Any] = dict(config)
+        if not merged.get("other_meaning_signals"):
+            merged["other_meaning_signals"] = AIRLINE_OTHER_MEANING_SIGNALS
+        if not merged.get("competitor_signals"):
+            merged["competitor_signals"] = AIRLINE_COMPETITOR_SIGNALS
+        # Optional: no default place list; config can add other_meaning_anchors for extra patterns
+        if "other_meaning_anchors" not in merged:
+            merged["other_meaning_anchors"] = []
+        if not merged.get("explicit_competitor_marker"):
+            merged["explicit_competitor_marker"] = AIRLINE_EXPLICIT_COMPETITOR_MARKER
+        if not merged.get("explicit_other_meaning_marker"):
+            merged["explicit_other_meaning_marker"] = AIRLINE_EXPLICIT_OTHER_MEANING_MARKER
+        if not merged.get("domain_words"):
+            merged["domain_words"] = ["airline", "airlines", "carrier"]
+        if not merged.get("competitors"):
+            merged["competitors"] = _load_competitors_excluding_brand(
+                merged.get("brand_self") or []
+            )
+        super().__init__(merged)
+        self._other_meaning_signals = list(merged.get("other_meaning_signals") or [])
+        self._competitor_signals = list(merged.get("competitor_signals") or [])
+        self._other_meaning_anchors = list(merged.get("other_meaning_anchors") or [])
+        self._explicit_competitor_marker = _compile_marker(
+            merged.get("explicit_competitor_marker")
+        )
+        self._explicit_other_meaning_marker = _compile_marker(
+            merged.get("explicit_other_meaning_marker")
+        )
+
+    def _classify_ambiguous(self, text: str, token: str) -> Tuple[str, float]:
+        """Other meaning vs competitor using airline signals and explicit markers."""
+        text_lower = text.lower()
+        if self._explicit_competitor_marker and self._explicit_competitor_marker.search(
+            text_lower
+        ) and _word_boundary_match(text_lower, token.lower()):
+            return "COMPETITOR", 0.85
+        if self._explicit_other_meaning_marker and self._explicit_other_meaning_marker.search(
+            text_lower
+        ):
+            return "OTHER_MEANING", 0.85
+        # Operational-only: baggage/lounge/check-in/refund with no comparison → product query
+        has_comparison = _count_signals(text_lower, AIRLINE_COMPARISON_SIGNALS) > 0
+        operational_count = _count_signals(text_lower, AIRLINE_OPERATIONAL_SIGNALS)
+        if not has_comparison and operational_count > 0:
+            return "OTHER_MEANING", 0.85
+        # Score: location/travel context vs airline context (no place-name list)
+        other_count = _count_signals(text_lower, self._other_meaning_signals)
+        if self._other_meaning_anchors:
+            other_count += _count_signals(text_lower, self._other_meaning_anchors)
+        comp_count = _count_signals(text_lower, self._competitor_signals)
+        total = other_count + comp_count
+        if total == 0:
+            return "OTHER_MEANING", 0.5
+        other_ratio = other_count / total
+        comp_ratio = comp_count / total
+        if other_ratio >= 0.6:
+            return "OTHER_MEANING", min(0.9, 0.5 + 0.4 * other_ratio)
+        if comp_ratio >= 0.6:
+            return "COMPETITOR", min(0.9, 0.5 + 0.4 * comp_ratio)
+        return "OTHER_MEANING", 0.5

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/competitor_intent/base.py

@@ -0,0 +1,272 @@
+"""
+Generic competitor intent checker: two entity sets and overridable disambiguation.
+"""
+
+import re
+import unicodedata
+from typing import Any, Dict, List, Optional, Pattern, Set, Tuple, cast
+
+from litellm.types.proxy.guardrails.guardrail_hooks.litellm_content_filter import (
+    CompetitorActionHint, CompetitorIntentEvidenceEntry,
+    CompetitorIntentResult)
+
+ZERO_WIDTH = re.compile(r"[\u200b-\u200d\u2060\ufeff]")
+LEET = {"@": "a", "4": "a", "0": "o", "3": "e", "1": "i", "5": "s", "7": "t"}
+
+OTHER_MEANING_DEFAULT_THRESHOLD = (
+    0.65  # Below this → treat as non-competitor (safe default).
+)
+
+
+def normalize(text: str) -> str:
+    """Lowercase, NFKC, strip zero-width, leetspeak, collapse spaces."""
+    if not text or not isinstance(text, str):
+        return ""
+    t = ZERO_WIDTH.sub("", text)
+    t = unicodedata.normalize("NFKC", t).lower().strip()
+    for c, r in LEET.items():
+        t = t.replace(c, r)
+    return re.sub(r"\s+", " ", t)
+
+
+def _word_boundary_match(text: str, token: str) -> bool:
+    """True if token appears as a word in text."""
+    return bool(re.search(r"\b" + re.escape(token) + r"\b", text))
+
+
+def _count_signals(text: str, patterns: List[str]) -> int:
+    """Count how many of the patterns appear in text."""
+    return sum(1 for p in patterns if re.search(p, text, re.IGNORECASE))
+
+
+def _compile_marker(pattern: Optional[str]) -> Optional[Pattern[str]]:
+    """Compile optional regex string to a pattern."""
+    if not pattern or not pattern.strip():
+        return None
+    try:
+        return re.compile(pattern, re.IGNORECASE)
+    except re.error:
+        return None
+
+
+def text_for_entity_matching(text: str) -> str:
+    """Letters-only variant for entity matching (e.g. split punctuation)."""
+    t = re.sub(r"[^\w\s]", " ", text)
+    return re.sub(r"\s+", " ", t).strip()
+
+
+class BaseCompetitorIntentChecker:
+    """
+    Generic competitor intent checker with two entity sets. Ambiguous tokens
+    (competitor + other-meaning, e.g. location) are classified by overridable
+    _classify_ambiguous(). Base implementation: treat as non-competitor.
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self.brand_self: List[str] = [
+            s.lower().strip() for s in (config.get("brand_self") or []) if s
+        ]
+        competitors: List[str] = [
+            s.lower().strip() for s in (config.get("competitors") or []) if s
+        ]
+        aliases_map: Dict[str, List[str]] = config.get("competitor_aliases") or {}
+        self.competitor_canonical: Dict[str, str] = {}
+        self._competitor_tokens: Set[str] = set()
+        for c in competitors:
+            self._competitor_tokens.add(c)
+            self.competitor_canonical[c] = c
+            for a in aliases_map.get(c) or []:
+                a = a.lower().strip()
+                if a:
+                    self._competitor_tokens.add(a)
+                    self.competitor_canonical[a] = c
+
+        other: List[str] = [
+            s.lower().strip() for s in (config.get("locations") or []) if s
+        ]
+        self._other_meaning_tokens: Set[str] = set(other)
+        self._ambiguous: Set[str] = self._competitor_tokens & self._other_meaning_tokens
+
+        self.policy: Dict[str, str] = config.get("policy") or {}
+        self.threshold_high = float(config.get("threshold_high", 0.70))
+        self.threshold_medium = float(config.get("threshold_medium", 0.45))
+        self.threshold_low = float(config.get("threshold_low", 0.30))
+        self.reframe_message_template: Optional[str] = config.get(
+            "reframe_message_template"
+        )
+        self.refuse_message_template: Optional[str] = config.get(
+            "refuse_message_template"
+        )
+        self._comparison_words: List[str] = list(
+            config.get("comparison_words")
+            or [
+                "better",
+                "worse",
+                "best",
+                "vs",
+                "versus",
+                "compare",
+                "alternative",
+                "recommend",
+                "ranked",
+            ]
+        )
+        self._domain_words: List[str] = [
+            s.lower().strip() for s in (config.get("domain_words") or []) if s
+        ]
+
+    def _classify_ambiguous(self, text: str, token: str) -> Tuple[str, float]:
+        """
+        Override in subclasses for industry-specific logic. Base: treat as non-competitor.
+        """
+        return "OTHER_MEANING", 0.5
+
+    def _find_matches(self, text: str) -> List[Tuple[str, str, bool]]:
+        """Find competitor matches; mark ambiguous (also in other-meaning set)."""
+        normalized = normalize(text)
+        found: List[Tuple[str, str, bool]] = []
+        seen: Set[Tuple[str, str]] = set()
+        for token in self._competitor_tokens:
+            if not _word_boundary_match(normalized, token):
+                continue
+            canonical = self.competitor_canonical.get(token, token)
+            key = (token, canonical)
+            if key in seen:
+                continue
+            seen.add(key)
+            is_ambig = token in self._ambiguous or token in self._other_meaning_tokens
+            found.append((token, canonical, is_ambig))
+        return found
+
+    def run(self, text: str) -> CompetitorIntentResult:
+        """Classify competitor intent; non-competitor when ambiguous or low confidence."""
+        normalized = normalize(text)
+        evidence: List[CompetitorIntentEvidenceEntry] = []
+        entities: Dict[str, List[str]] = {
+            "brand_self": [],
+            "competitors": [],
+            "category": [],
+        }
+
+        for b in self.brand_self:
+            if _word_boundary_match(normalized, b):
+                entities["brand_self"].append(b)
+                evidence.append(
+                    {"type": "entity", "key": "brand_self", "value": b, "match": b}
+                )
+
+        matches = self._find_matches(text)
+        if not matches:
+            has_comparison = any(
+                re.search(r"\b" + re.escape(w) + r"\b", normalized)
+                for w in self._comparison_words
+            )
+            has_domain = self._domain_words and any(
+                re.search(r"\b" + re.escape(w) + r"\b", normalized)
+                for w in self._domain_words
+            )
+            if has_comparison and has_domain:
+                evidence.append(
+                    {
+                        "type": "signal",
+                        "key": "category_ranking",
+                        "match": "comparison + domain",
+                    }
+                )
+                action_hint = cast(
+                    CompetitorActionHint,
+                    self.policy.get("category_ranking", "reframe"),
+                )
+                return {
+                    "intent": "category_ranking",
+                    "confidence": 0.65,
+                    "entities": entities,
+                    "signals": ["category_ranking"],
+                    "action_hint": action_hint,
+                    "evidence": evidence,
+                }
+            return {
+                "intent": "other",
+                "confidence": 0.0,
+                "entities": entities,
+                "signals": [],
+                "action_hint": "allow",
+                "evidence": evidence,
+            }
+
+        competitor_resolved: List[str] = []
+        for token, canonical, _ in matches:
+            label, conf = self._classify_ambiguous(normalized, token)
+            if label == "OTHER_MEANING":
+                evidence.append(
+                    {"type": "signal", "key": "other_meaning", "match": token}
+                )
+                continue
+            if label == "COMPETITOR":
+                competitor_resolved.append(canonical)
+                evidence.append(
+                    {
+                        "type": "entity",
+                        "key": "competitor",
+                        "value": canonical,
+                        "match": token,
+                    }
+                )
+                if conf < OTHER_MEANING_DEFAULT_THRESHOLD:
+                    competitor_resolved.pop()
+                    evidence.append(
+                        {
+                            "type": "signal",
+                            "key": "other_meaning_default",
+                            "match": f"confidence {conf:.2f}",
+                        }
+                    )
+                    continue
+
+        entities["competitors"] = list(dict.fromkeys(competitor_resolved))
+
+        if not competitor_resolved:
+            return {
+                "intent": "other",
+                "confidence": 0.0,
+                "entities": entities,
+                "signals": ["other_meaning_or_ambiguous"],
+                "action_hint": "allow",
+                "evidence": evidence,
+            }
+
+        has_comparison = any(
+            re.search(r"\b" + re.escape(w) + r"\b", normalized)
+            for w in self._comparison_words
+        )
+        if has_comparison:
+            evidence.append(
+                {"type": "signal", "key": "comparison", "match": "comparison language"}
+            )
+        confidence = 0.75 if has_comparison else 0.55
+        if confidence >= self.threshold_high:
+            intent = "competitor_comparison"
+        elif confidence >= self.threshold_medium:
+            intent = "possible_competitor_comparison"
+        elif confidence >= self.threshold_low:
+            intent = "log_only"
+        else:
+            intent = "other"
+
+        action_hint: CompetitorActionHint = cast(
+            CompetitorActionHint, self.policy.get(intent, "allow")
+        )
+        if intent == "log_only":
+            action_hint = "log_only"
+        if intent == "other":
+            action_hint = "allow"
+
+        return {
+            "intent": intent,
+            "confidence": round(confidence, 2),
+            "entities": entities,
+            "signals": ["competitor_resolved"]
+            + (["comparison"] if has_comparison else []),
+            "action_hint": action_hint,
+            "evidence": evidence,
+        }

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/content_filter.py

@@ -10,19 +10,8 @@ import json
 import os
 import re
 from datetime import datetime
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncGenerator,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Pattern,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import (TYPE_CHECKING, Any, AsyncGenerator, Dict, List, Literal,
+                    Optional, Pattern, Tuple, Union, cast)
 
 import yaml
 from fastapi import HTTPException
@@ -31,31 +20,22 @@ from litellm import Router
 from litellm._logging import verbose_proxy_logger
 from litellm.integrations.custom_guardrail import CustomGuardrail
 from litellm.proxy._types import UserAPIKeyAuth
-from litellm.types.utils import (
-    GenericGuardrailAPIInputs,
-    GuardrailStatus,
-    GuardrailTracingDetail,
-    ModelResponseStream,
-)
+from litellm.types.utils import (GenericGuardrailAPIInputs, GuardrailStatus,
+                                 GuardrailTracingDetail, ModelResponseStream)
 
 if TYPE_CHECKING:
     from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
 
-from litellm.types.guardrails import (
-    BlockedWord,
-    ContentFilterAction,
-    ContentFilterPattern,
-    GuardrailEventHooks,
-    Mode,
-)
+from litellm.types.guardrails import (BlockedWord, ContentFilterAction,
+                                      ContentFilterPattern,
+                                      GuardrailEventHooks, Mode)
 from litellm.types.proxy.guardrails.guardrail_hooks.litellm_content_filter import (
-    BlockedWordDetection,
-    CategoryKeywordDetection,
-    ContentFilterCategoryConfig,
-    ContentFilterDetection,
-    PatternDetection,
-)
+    BlockedWordDetection, CategoryKeywordDetection, CompetitorIntentDetection,
+    CompetitorIntentResult, ContentFilterCategoryConfig,
+    ContentFilterDetection, PatternDetection)
 
+from .competitor_intent import (AirlineCompetitorIntentChecker,
+                                BaseCompetitorIntentChecker)
 from .patterns import PATTERN_EXTRA_CONFIG, get_compiled_pattern
 
 MAX_KEYWORD_VALUE_GAP_WORDS = 1
@@ -162,6 +142,7 @@ class ContentFilterGuardrail(CustomGuardrail):
         severity_threshold: str = "medium",
         llm_router: Optional[Router] = None,
         image_model: Optional[str] = None,
+        competitor_intent_config: Optional[Dict[str, Any]] = None,
         **kwargs,
     ):
         """
@@ -212,6 +193,31 @@ class ContentFilterGuardrail(CustomGuardrail):
             {}
         )  # category_name -> {identifier_words, block_words, action, severity}
 
+        # Competitor intent checker (optional; airline uses major_airlines.json, generic requires competitors)
+        self._competitor_intent_checker: Optional[BaseCompetitorIntentChecker] = None
+        if competitor_intent_config and isinstance(competitor_intent_config, dict):
+            try:
+                competitor_intent_type = competitor_intent_config.get(
+                    "competitor_intent_type", "airline"
+                )
+                if competitor_intent_type == "generic":
+                    self._competitor_intent_checker = BaseCompetitorIntentChecker(
+                        competitor_intent_config
+                    )
+                else:
+                    self._competitor_intent_checker = AirlineCompetitorIntentChecker(
+                        competitor_intent_config
+                    )
+                verbose_proxy_logger.debug(
+                    "ContentFilterGuardrail: competitor intent checker enabled (%s)",
+                    competitor_intent_type,
+                )
+            except Exception as e:
+                verbose_proxy_logger.warning(
+                    "ContentFilterGuardrail: failed to init competitor intent checker: %s",
+                    e,
+                )
+
         # Load categories if provided
         if categories:
             self._load_categories(categories)
@@ -1220,9 +1226,7 @@ class ContentFilterGuardrail(CustomGuardrail):
                 pattern_name=pattern_name.upper()
             )
             text = self._mask_spans(text, spans, redaction_tag)
-            verbose_proxy_logger.info(
-                f"Masked all {pattern_name} matches in content"
-            )
+            verbose_proxy_logger.info(f"Masked all {pattern_name} matches in content")
 
         return text
 
@@ -1453,7 +1457,9 @@ class ContentFilterGuardrail(CustomGuardrail):
             masked_entity_count: Dictionary to update with counts
         """
         for detection in detections:
-            if detection["action"] == ContentFilterAction.MASK.value:
+            if detection.get("type") == "competitor_intent":
+                continue
+            if detection.get("action") == ContentFilterAction.MASK.value:
                 detection_type = detection["type"]
                 if detection_type == "pattern":
                     pattern_detection = cast(PatternDetection, detection)
@@ -1479,18 +1485,27 @@ class ContentFilterGuardrail(CustomGuardrail):
         """Build match_details list from content filter detections."""
         match_details: List[dict] = []
         for detection in detections:
-            detail: dict = {"type": detection["type"], "action_taken": detection["action"]}
+            action_taken = detection.get("action", detection.get("action_hint", ""))
+            detail: dict = {"type": detection["type"], "action_taken": action_taken}
             if detection["type"] == "pattern":
                 detail["detection_method"] = "regex"
-                detail["snippet"] = cast(PatternDetection, detection).get("pattern_name", "")
+                detail["snippet"] = cast(PatternDetection, detection).get(
+                    "pattern_name", ""
+                )
             elif detection["type"] == "blocked_word":
                 detail["detection_method"] = "keyword"
-                detail["snippet"] = cast(BlockedWordDetection, detection).get("keyword", "")
+                detail["snippet"] = cast(BlockedWordDetection, detection).get(
+                    "keyword", ""
+                )
             elif detection["type"] == "category_keyword":
                 detail["detection_method"] = "keyword"
                 cat_det = cast(CategoryKeywordDetection, detection)
                 detail["snippet"] = cat_det.get("keyword", "")
                 detail["category"] = cat_det.get("category", "")
+            elif detection["type"] == "competitor_intent":
+                detail["detection_method"] = "intent"
+                detail["snippet"] = detection.get("intent", "")
+                detail["confidence"] = detection.get("confidence")
             match_details.append(detail)
         return match_details
 
@@ -1500,19 +1515,28 @@ class ContentFilterGuardrail(CustomGuardrail):
         for detection in detections:
             if detection["type"] == "pattern":
                 methods.add("regex")
+            elif detection["type"] == "competitor_intent":
+                methods.add("intent")
             else:
                 methods.add("keyword")
         return ",".join(sorted(methods)) if methods else ""
 
     def _get_patterns_checked_count(self) -> int:
         """Get total number of patterns and keywords that were evaluated."""
-        return len(self.compiled_patterns) + len(self.blocked_words) + len(self.category_keywords)
+        return (
+            len(self.compiled_patterns)
+            + len(self.blocked_words)
+            + len(self.category_keywords)
+        )
 
     def _get_policy_templates(self) -> Optional[str]:
         """Get comma-separated policy template names from loaded categories."""
         if not self.loaded_categories:
             return None
-        names = [cat.description or cat.category_name for cat in self.loaded_categories.values()]
+        names = [
+            cat.description or cat.category_name
+            for cat in self.loaded_categories.values()
+        ]
         return ", ".join(names) if names else None
 
     def _compute_risk_score(
@@ -1550,6 +1574,72 @@ class ContentFilterGuardrail(CustomGuardrail):
 
         return round(min(10.0, score), 1)
 
+    def _apply_competitor_intent_policy(
+        self,
+        intent_result: CompetitorIntentResult,
+        request_data: dict,
+        detections: List[ContentFilterDetection],
+    ) -> None:
+        """
+        Apply policy for competitor intent result: refuse (raise), reframe (passthrough), or log_only/allow (return).
+        Appends competitor_intent detection to detections. Never returns for refuse/reframe.
+        """
+        intent_val = intent_result.get("intent", "other")
+        confidence_val = intent_result.get("confidence", 0.0)
+        action_hint_val = intent_result.get("action_hint", "allow")
+        evidence_list = intent_result.get("evidence", [])
+        detection: CompetitorIntentDetection = {
+            "type": "competitor_intent",
+            "intent": intent_val,
+            "confidence": confidence_val,
+            "action_hint": action_hint_val,
+            "entities": intent_result.get("entities", {}),
+            "signals": intent_result.get("signals", []),
+            "evidence": [dict(e) for e in evidence_list],
+        }
+        detections.append(detection)
+
+        if action_hint_val == "refuse":
+            msg = "Content blocked: competitor comparison or ranking intent detected."
+            if self._competitor_intent_checker and getattr(
+                self._competitor_intent_checker, "refuse_message_template", None
+            ):
+                msg = self._competitor_intent_checker.refuse_message_template or msg
+            verbose_proxy_logger.warning(
+                "ContentFilterGuardrail: competitor intent refuse - %s", intent_val
+            )
+            raise HTTPException(
+                status_code=403,
+                detail={
+                    "error": msg,
+                    "intent": intent_val,
+                    "confidence": confidence_val,
+                },
+            )
+        if action_hint_val == "reframe":
+            msg = (
+                "I can help with questions about our products and services. "
+                "Would you like to compare specific features or get more information?"
+            )
+            if self._competitor_intent_checker and getattr(
+                self._competitor_intent_checker, "reframe_message_template", None
+            ):
+                msg = self._competitor_intent_checker.reframe_message_template or msg
+            verbose_proxy_logger.info(
+                "ContentFilterGuardrail: competitor intent reframe - %s", intent_val
+            )
+            self.raise_passthrough_exception(
+                violation_message=msg,
+                request_data=request_data,
+                detection_info=dict(intent_result),
+            )
+        # log_only or allow: just log (detection already appended)
+        verbose_proxy_logger.debug(
+            "ContentFilterGuardrail: competitor intent %s (action_hint=%s)",
+            intent_val,
+            action_hint_val,
+        )
+
     def _log_guardrail_information(
         self,
         request_data: dict,
@@ -1581,6 +1671,28 @@ class ContentFilterGuardrail(CustomGuardrail):
                 else [dict(detection) for detection in detections]
             )
 
+        # Competitor intent: add confidence and classification to tracing if present
+        tracing_kw: Dict[str, Any] = {
+            "guardrail_id": self.config_guardrail_id or self.guardrail_name,
+            "policy_template": self.config_policy_template
+            or self._get_policy_templates(),
+            "detection_method": (
+                self._get_detection_methods(detections) if detections else None
+            ),
+            "match_details": (
+                self._build_match_details(detections) if detections else None
+            ),
+            "patterns_checked": self._get_patterns_checked_count(),
+            "risk_score": self._compute_risk_score(
+                detections, masked_entity_count, status
+            ),
+        }
+        for d in detections:
+            if isinstance(d, dict) and d.get("type") == "competitor_intent":
+                tracing_kw["confidence_score"] = d.get("confidence")
+                tracing_kw["classification"] = dict(d)
+                break
+
         self.add_standard_logging_guardrail_information_to_request_data(
             guardrail_provider=self.guardrail_provider,
             guardrail_json_response=guardrail_json_response,
@@ -1590,14 +1702,7 @@ class ContentFilterGuardrail(CustomGuardrail):
             end_time=datetime.now().timestamp(),
             duration=(datetime.now() - start_time).total_seconds(),
             masked_entity_count=masked_entity_count,
-            tracing_detail=GuardrailTracingDetail(
-                guardrail_id=self.config_guardrail_id or self.guardrail_name,
-                policy_template=self.config_policy_template or self._get_policy_templates(),
-                detection_method=self._get_detection_methods(detections) if detections else None,
-                match_details=self._build_match_details(detections) if detections else None,
-                patterns_checked=self._get_patterns_checked_count(),
-                risk_score=self._compute_risk_score(detections, masked_entity_count, status),
-            ),
+            tracing_detail=GuardrailTracingDetail(**tracing_kw),
         )
 
     async def apply_guardrail(
@@ -1645,6 +1750,13 @@ class ContentFilterGuardrail(CustomGuardrail):
 
             processed_texts = []
             for text in texts:
+                # Competitor intent check first (optional; may refuse/reframe)
+                if self._competitor_intent_checker and text:
+                    intent_result = self._competitor_intent_checker.run(text)
+                    if intent_result.get("intent", "other") != "other":
+                        self._apply_competitor_intent_policy(
+                            intent_result, request_data, detections
+                        )
                 filtered_text = self._filter_single_text(text, detections=detections)
                 processed_texts.append(filtered_text)
 
@@ -1766,8 +1878,7 @@ class ContentFilterGuardrail(CustomGuardrail):
 
     @staticmethod
     def get_config_model():
-        from litellm.types.proxy.guardrails.guardrail_hooks.litellm_content_filter import (
-            LitellmContentFilterGuardrailConfigModel,
-        )
+        from litellm.types.proxy.guardrails.guardrail_hooks.litellm_content_filter import \
+            LitellmContentFilterGuardrailConfigModel
 
-        return LitellmContentFilterGuardrailConfigModel
+        return LitellmContentFilterGuardrailConfigModel

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/examples/README.md

@@ -0,0 +1,58 @@
+# Content Filter Examples
+
+## Industry-specific competitor intent (airline)
+
+Use **competitor_intent_type: airline** for simplified config; competitors are auto-loaded from IATA `major_airlines.json`, excluding your `brand_self`. Use **competitor_intent_type: generic** when you want to specify competitors manually.
+
+- **brand_self**: Your brand names and aliases (e.g. `["your-brand", "your-code"]`)
+- **competitors** (generic only): List of competitor names
+
+To make it effective for a specific industry (e.g. airlines), add an **industry layer** on top:
+
+1. **domain_words** – Terms that signal “this is about our vertical.”  
+   For airline: `airline`, `carrier`, `flight`, `business class`, `lounge`, etc.  
+   This enables the **category_ranking** path (e.g. “Which Gulf airline is the best?”) and the scoring **gate** (so “best” alone doesn’t trigger without domain/geo).
+
+2. **route_geo_cues** – Optional geography/hub terms.  
+   For airline: `country`, `hub-city`, `airport-code`, `region`.
+
+3. **descriptor_lexicon** – Phrases that count as indirect competitor reference.  
+   For aviation: `gulf carrier`, `five star airline`, etc.
+
+4. **competitor_aliases** – Per-competitor aliases (IATA codes, nicknames).  
+   Example: `competitor-name` → `["iata-code", "nickname"]`.
+
+5. **policy** – What to do per intent band: `refuse`, `reframe`, `log_only`, or `allow`.  
+   Example: `competitor_comparison: refuse`, `category_ranking: reframe`.
+
+See the config examples below for how to add this to your proxy `guardrails` config.
+
+### Using the example in your proxy config
+
+In `config.yaml`:
+
+```yaml
+guardrails:
+  - guardrail_name: "airline-competitor-intent"
+    litellm_params:
+      guardrail: litellm_content_filter
+      mode: pre_call
+      competitor_intent_config:
+        competitor_intent_type: airline
+        brand_self: [your-brand, your-code]
+        locations: [relevant-country, hub-city]
+        policy:
+          competitor_comparison: refuse
+          possible_competitor_comparison: reframe
+```
+
+Then attach this guardrail to your router/policy (e.g. `guardrails.add: [airline-competitor-intent]`).
+
+### Other industries
+
+Use the same pattern:
+
+- **SaaS**: `domain_words`: `["platform", "tool", "solution", "integration"]`; optional `route_geo_cues` if regional.
+- **Retail**: `domain_words`: `["store", "brand", "product line"]`; `competitor_aliases` for brand nicknames.
+
+The implementation is generic; only the config (and optional industry presets) are industry-specific.

litellm/proxy/guardrails/guardrail_hooks/litellm_content_filter/patterns.py

@@ -162,11 +162,9 @@ def get_available_content_categories() -> List[Dict[str, str]]:
                     category_data = yaml.safe_load(f)
 
                 if category_data and "category_name" in category_data:
-                    # Use explicit display_name from YAML if provided,
-                    # otherwise auto-generate from category_name
-                    display_name = category_data.get(
-                        "display_name",
-                        category_data["category_name"].replace("_", " ").title(),
+                    # Use explicit display_name if provided, otherwise auto-generate from category_name
+                    display_name = category_data.get("display_name") or (
+                        category_data["category_name"].replace("_", " ").title()
                     )
 
                     available_categories.append(

litellm/proxy/management_endpoints/policy_endpoints/endpoints.py

@@ -12,14 +12,7 @@ All /policy management endpoints
 import copy
 import json
 import os
-from typing import (
-    TYPE_CHECKING,
-    AsyncIterator,
-    List,
-    Literal,
-    Optional,
-    cast,
-)
+from typing import TYPE_CHECKING, AsyncIterator, List, Literal, Optional, cast
 
 from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.responses import StreamingResponse
@@ -27,11 +20,9 @@ from pydantic import BaseModel, Field
 from typing_extensions import TypedDict
 
 from litellm._logging import verbose_proxy_logger
-from litellm.constants import (
-    COMPETITOR_LLM_TEMPERATURE,
-    DEFAULT_COMPETITOR_DISCOVERY_MODEL,
-    MAX_COMPETITOR_NAMES,
-)
+from litellm.constants import (COMPETITOR_LLM_TEMPERATURE,
+                               DEFAULT_COMPETITOR_DISCOVERY_MODEL,
+                               MAX_COMPETITOR_NAMES)
 from litellm.integrations.custom_guardrail import CustomGuardrail
 from litellm.proxy._types import UserAPIKeyAuth
 from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
@@ -39,21 +30,20 @@ from litellm.proxy.guardrails.guardrail_registry import GuardrailRegistry
 from litellm.proxy.management_helpers.utils import management_endpoint_wrapper
 from litellm.proxy.policy_engine.policy_registry import get_policy_registry
 from litellm.proxy.policy_engine.policy_resolver import PolicyResolver
-from litellm.types.proxy.policy_engine import (
-    PolicyGuardrailsResponse,
-    PolicyInfoResponse,
-    PolicyListResponse,
-    PolicyMatchContext,
-    PolicyScopeResponse,
-    PolicySummaryItem,
-    PolicyTestResponse,
-    PolicyValidateRequest,
-    PolicyValidationResponse,
-)
+from litellm.types.proxy.policy_engine import (PolicyGuardrailsResponse,
+                                               PolicyInfoResponse,
+                                               PolicyListResponse,
+                                               PolicyMatchContext,
+                                               PolicyScopeResponse,
+                                               PolicySummaryItem,
+                                               PolicyTestResponse,
+                                               PolicyValidateRequest,
+                                               PolicyValidationResponse)
 from litellm.types.utils import GenericGuardrailAPIInputs
 
 if TYPE_CHECKING:
-    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+    from litellm.litellm_core_utils.litellm_logging import \
+        Logging as LiteLLMLoggingObj
 
 router = APIRouter()
 
@@ -86,6 +76,19 @@ class ApplyPoliciesResult(TypedDict):
     guardrail_errors: List[GuardrailErrorEntry]
 
 
+class ApplyPoliciesPerItemResult(TypedDict):
+    """Result for one input when using inputs_list."""
+
+    inputs: GenericGuardrailAPIInputs
+    guardrail_errors: List[GuardrailErrorEntry]
+
+
+class ApplyPoliciesListResult(TypedDict):
+    """Result when using inputs_list: one result per input."""
+
+    results: List[ApplyPoliciesPerItemResult]
+
+
 async def apply_policies(
     policy_names: Optional[list[str]],
     inputs: GenericGuardrailAPIInputs,
@@ -187,7 +190,14 @@ class TestPoliciesAndGuardrailsRequest(BaseModel):
 
     policy_names: Optional[List[str]] = Field(default=None, description="Policy names to resolve guardrails from")
     guardrail_names: Optional[List[str]] = Field(default=None, description="Guardrail names to apply directly")
-    inputs: dict = Field(description="GenericGuardrailAPIInputs, e.g. { \"texts\": [\"...\"] }")
+    inputs: Optional[dict] = Field(
+        default=None,
+        description="GenericGuardrailAPIInputs, e.g. { \"texts\": [\"...\"] }. Use inputs_list for per-input processing.",
+    )
+    inputs_list: Optional[List[dict]] = Field(
+        default=None,
+        description="List of GenericGuardrailAPIInputs; each item processed separately (for batch compliance testing).",
+    )
     request_data: dict = Field(default_factory=dict, description="Request context (model, user_id, etc.)")
     input_type: Literal["request", "response"] = Field(default="request", description="Whether inputs are request or response")
 
@@ -206,26 +216,48 @@ async def test_policies_and_guardrails(
     """
     Apply policies and/or guardrails to inputs (for compliance UI testing).
 
-    Runs all guardrails in order; failures are collected and returned in guardrail_errors.
-    Returns inputs (possibly modified) and any guardrail errors so the UI can show which
-    guardrails failed and why.
+    Use inputs_list for batch testing: each input is processed as a separate call so
+    per-input block/allow and errors are returned.
+
+    Use inputs for a single call (legacy).
     """
-    from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+    from litellm.litellm_core_utils.litellm_logging import \
+        Logging as LiteLLMLoggingObj
     from litellm.proxy.proxy_server import proxy_logging_obj
     from litellm.proxy.utils import handle_exception_on_proxy
 
     try:
-        inputs_typed = cast(GenericGuardrailAPIInputs, data.inputs)
         logging_obj = cast(LiteLLMLoggingObj, proxy_logging_obj)
-        result = await apply_policies(
-            policy_names=data.policy_names,
-            inputs=inputs_typed,
-            request_data=data.request_data,
-            input_type=data.input_type,
-            proxy_logging_obj=logging_obj,
-            guardrail_names=data.guardrail_names,
-        )
-        return result
+        if data.inputs_list is not None:
+            results: List[ApplyPoliciesPerItemResult] = []
+            for inp in data.inputs_list:
+                inputs_typed = cast(GenericGuardrailAPIInputs, inp)
+                item_result = await apply_policies(
+                    policy_names=data.policy_names,
+                    inputs=inputs_typed,
+                    request_data=data.request_data,
+                    input_type=data.input_type,
+                    proxy_logging_obj=logging_obj,
+                    guardrail_names=data.guardrail_names,
+                )
+                results.append(
+                    ApplyPoliciesPerItemResult(
+                        inputs=item_result["inputs"],
+                        guardrail_errors=item_result["guardrail_errors"],
+                    )
+                )
+            return ApplyPoliciesListResult(results=results)
+        if data.inputs is not None:
+            inputs_typed = cast(GenericGuardrailAPIInputs, data.inputs)
+            return await apply_policies(
+                policy_names=data.policy_names,
+                inputs=inputs_typed,
+                request_data=data.request_data,
+                input_type=data.input_type,
+                proxy_logging_obj=logging_obj,
+                guardrail_names=data.guardrail_names,
+            )
+        raise ValueError("Either inputs or inputs_list must be provided")
     except Exception as e:
         raise handle_exception_on_proxy(e)
 
@@ -506,7 +538,8 @@ async def get_policy_templates(
         return _load_policy_templates_from_local_backup()
 
     try:
-        from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
+        from litellm.llms.custom_httpx.http_handler import \
+            get_async_httpx_client
         from litellm.types.llms.custom_http import httpxSpecialProvider
 
         async_client = get_async_httpx_client(
@@ -981,9 +1014,8 @@ async def suggest_policy_templates(
 
     Calls an LLM with tool calling to match user requirements to available templates.
     """
-    from litellm.proxy.management_endpoints.policy_endpoints.ai_policy_suggester import (
-        AiPolicySuggester,
-    )
+    from litellm.proxy.management_endpoints.policy_endpoints.ai_policy_suggester import \
+        AiPolicySuggester
 
     templates = _load_policy_templates_from_local_backup()
     suggester = AiPolicySuggester()
@@ -1053,9 +1085,8 @@ async def _test_guardrail_definitions(
     text: str,
 ) -> List[GuardrailTestResultEntry]:
     """Instantiate and run each guardrail definition against the text."""
-    from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import (
-        ContentFilterGuardrail,
-    )
+    from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import \
+        ContentFilterGuardrail
 
     results: List[GuardrailTestResultEntry] = []
 

litellm/proxy/proxy_server.py

@@ -388,10 +388,10 @@ from litellm.proxy.management_endpoints.model_management_endpoints import (
 from litellm.proxy.management_endpoints.organization_endpoints import (
     router as organization_router,
 )
+from litellm.proxy.management_endpoints.policy_endpoints import router as policy_router
 from litellm.proxy.management_endpoints.project_endpoints import (
     router as project_router,
 )
-from litellm.proxy.management_endpoints.policy_endpoints import router as policy_router
 from litellm.proxy.management_endpoints.router_settings_endpoints import (
     router as router_settings_router,
 )
@@ -902,6 +902,15 @@ async def proxy_startup_event(app: FastAPI):  # noqa: PLR0915
         except Exception as e:
             verbose_proxy_logger.error(f"Error stopping token refresh task: {e}")
 
+    # Shutdown event - stop Prisma DB health watchdog task
+    if prisma_client is not None and hasattr(
+        prisma_client, "stop_db_health_watchdog_task"
+    ):
+        try:
+            await prisma_client.stop_db_health_watchdog_task()
+        except Exception as e:
+            verbose_proxy_logger.error(f"Error stopping DB health watchdog task: {e}")
+
     await proxy_shutdown_event()  # type: ignore[reportGeneralTypeIssues]
 
 
@@ -5829,6 +5838,9 @@ class ProxyStartupEvent:
                     is not True
                 ):
                     await prisma_client.health_check()
+
+                if hasattr(prisma_client, "start_db_health_watchdog_task"):
+                    await prisma_client.start_db_health_watchdog_task()
             return prisma_client
         except Exception as e:
             PrismaDBExceptionHandler.handle_db_exception(e)

litellm/proxy/utils.py

@@ -102,6 +102,7 @@ from litellm.proxy.db.create_views import (
     should_create_missing_views,
 )
 from litellm.proxy.db.db_spend_update_writer import DBSpendUpdateWriter
+from litellm.proxy.db.exception_handler import PrismaDBExceptionHandler
 from litellm.proxy.db.log_db_metrics import log_db_metrics
 from litellm.proxy.db.prisma_client import PrismaWrapper
 from litellm.proxy.guardrails.guardrail_hooks.unified_guardrail.unified_guardrail import (
@@ -2266,6 +2267,32 @@ class PrismaClient:
                     else False
                 ),
             )  # Client to connect to Prisma db
+        self._db_reconnect_lock = asyncio.Lock()
+        self._db_health_watchdog_task: Optional[asyncio.Task] = None
+        self._db_last_reconnect_attempt_ts: float = 0.0
+        self._db_reconnect_cooldown_seconds: int = max(
+            1, int(os.getenv("PRISMA_RECONNECT_COOLDOWN_SECONDS", "15"))
+        )
+        self._db_health_watchdog_interval_seconds: int = max(
+            5, int(os.getenv("PRISMA_HEALTH_WATCHDOG_INTERVAL_SECONDS", "30"))
+        )
+        self._db_health_watchdog_enabled: bool = (
+            str_to_bool(os.getenv("PRISMA_HEALTH_WATCHDOG_ENABLED", "true")) is True
+        )
+        self._db_health_watchdog_probe_timeout_seconds: float = max(
+            0.5,
+            float(os.getenv("PRISMA_HEALTH_WATCHDOG_PROBE_TIMEOUT_SECONDS", "5.0")),
+        )
+        self._db_watchdog_reconnect_timeout_seconds: float = max(
+            1.0, float(os.getenv("PRISMA_WATCHDOG_RECONNECT_TIMEOUT_SECONDS", "30.0"))
+        )
+        self._db_auth_reconnect_timeout_seconds: float = max(
+            0.5, float(os.getenv("PRISMA_AUTH_RECONNECT_TIMEOUT_SECONDS", "2.0"))
+        )
+        self._db_auth_reconnect_lock_timeout_seconds: float = max(
+            0.0,
+            float(os.getenv("PRISMA_AUTH_RECONNECT_LOCK_TIMEOUT_SECONDS", "0.1")),
+        )
         verbose_proxy_logger.debug("Success - Created Prisma Client")
 
     def get_request_status(
@@ -3533,6 +3560,207 @@ class PrismaClient:
             )
             raise e
 
+    async def _run_reconnect_cycle(
+        self, timeout_seconds: Optional[float] = None
+    ) -> None:
+        """
+        Run a reconnect cycle with direct db operations and a single overall timeout
+        budget to avoid long retries on hot paths (e.g. auth).
+        """
+        async def _do_direct_reconnect() -> None:
+            try:
+                await self.db.disconnect()
+            except Exception as disconnect_err:
+                verbose_proxy_logger.debug(
+                    "Prisma DB disconnect before reconnect failed (ignored): %s",
+                    disconnect_err,
+                )
+
+            await self.db.connect()
+            await self.db.query_raw("SELECT 1")
+
+        effective_timeout = (
+            timeout_seconds
+            if timeout_seconds is not None
+            else self._db_watchdog_reconnect_timeout_seconds
+        )
+        await asyncio.wait_for(_do_direct_reconnect(), timeout=effective_timeout)
+
+    async def attempt_db_reconnect(
+        self,
+        reason: str,
+        force: bool = False,
+        timeout_seconds: Optional[float] = None,
+        lock_timeout_seconds: Optional[float] = None,
+    ) -> bool:
+        """
+        Attempt to reconnect the Prisma client in a singleflight manner.
+
+        Returns:
+            bool: True if reconnection succeeded, else False.
+        """
+        now = time.time()
+        if (
+            force is False
+            and now - self._db_last_reconnect_attempt_ts
+            < self._db_reconnect_cooldown_seconds
+        ):
+            verbose_proxy_logger.debug(
+                "Skipping DB reconnect attempt due to cooldown. reason=%s",
+                reason,
+            )
+            return False
+
+        async def _attempt_reconnect_inside_lock() -> bool:
+            now = time.time()
+            if (
+                force is False
+                and now - self._db_last_reconnect_attempt_ts
+                < self._db_reconnect_cooldown_seconds
+            ):
+                verbose_proxy_logger.debug(
+                    "Skipping DB reconnect attempt inside lock due to cooldown. reason=%s",
+                    reason,
+                )
+                return False
+
+            verbose_proxy_logger.warning(
+                "Attempting Prisma DB reconnect. reason=%s", reason
+            )
+
+            reconnect_succeeded = False
+            try:
+                await self._run_reconnect_cycle(timeout_seconds=timeout_seconds)
+                reconnect_succeeded = True
+                verbose_proxy_logger.info(
+                    "Prisma DB reconnect succeeded. reason=%s", reason
+                )
+            except Exception as reconnect_err:
+                verbose_proxy_logger.error(
+                    "Prisma DB reconnect failed. reason=%s error=%s",
+                    reason,
+                    reconnect_err,
+                )
+            finally:
+                # Start cooldown after reconnect attempt has completed.
+                self._db_last_reconnect_attempt_ts = time.time()
+
+            return reconnect_succeeded
+
+        if lock_timeout_seconds is None:
+            async with self._db_reconnect_lock:
+                return await _attempt_reconnect_inside_lock()
+
+        lock_acquired_by_timeout_task = False
+
+        async def _acquire_reconnect_lock() -> bool:
+            nonlocal lock_acquired_by_timeout_task
+            await self._db_reconnect_lock.acquire()
+            lock_acquired_by_timeout_task = True
+            return True
+
+        acquire_task = asyncio.create_task(_acquire_reconnect_lock())
+        done, _pending = await asyncio.wait(
+            {acquire_task},
+            timeout=lock_timeout_seconds,
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if acquire_task not in done:
+            acquire_task.cancel()
+            try:
+                await acquire_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+
+            # Defensive cleanup for timeout/cancel race on Python 3.9-3.11.
+            if lock_acquired_by_timeout_task:
+                try:
+                    self._db_reconnect_lock.release()
+                except RuntimeError:
+                    pass
+            verbose_proxy_logger.debug(
+                "Skipping DB reconnect attempt due to lock acquisition timeout. reason=%s timeout=%ss",
+                reason,
+                lock_timeout_seconds,
+            )
+            return False
+
+        try:
+            acquire_task.result()
+        except Exception as lock_acquire_err:
+            verbose_proxy_logger.debug(
+                "Skipping DB reconnect attempt due to lock acquisition error. reason=%s error=%s",
+                reason,
+                lock_acquire_err,
+            )
+            return False
+
+        try:
+            return await _attempt_reconnect_inside_lock()
+        finally:
+            self._db_reconnect_lock.release()
+
+    async def start_db_health_watchdog_task(self) -> None:
+        """
+        Start a background task that probes DB health and attempts reconnect on failure.
+        """
+        if self._db_health_watchdog_enabled is not True:
+            verbose_proxy_logger.debug(
+                "Prisma DB health watchdog disabled via PRISMA_HEALTH_WATCHDOG_ENABLED"
+            )
+            return
+        if self._db_health_watchdog_task is not None:
+            return
+        self._db_health_watchdog_task = asyncio.create_task(
+            self._db_health_watchdog_loop()
+        )
+        verbose_proxy_logger.info(
+            "Started Prisma DB health watchdog (interval=%ss, reconnect_cooldown=%ss, probe_timeout=%ss, reconnect_timeout=%ss)",
+            self._db_health_watchdog_interval_seconds,
+            self._db_reconnect_cooldown_seconds,
+            self._db_health_watchdog_probe_timeout_seconds,
+            self._db_watchdog_reconnect_timeout_seconds,
+        )
+
+    async def stop_db_health_watchdog_task(self) -> None:
+        """
+        Stop DB health watchdog task gracefully.
+        """
+        if self._db_health_watchdog_task is None:
+            return
+        self._db_health_watchdog_task.cancel()
+        try:
+            await self._db_health_watchdog_task
+        except asyncio.CancelledError:
+            pass
+        self._db_health_watchdog_task = None
+        verbose_proxy_logger.info("Stopped Prisma DB health watchdog")
+
+    async def _db_health_watchdog_loop(self) -> None:
+        while True:
+            try:
+                await asyncio.sleep(self._db_health_watchdog_interval_seconds)
+                await asyncio.wait_for(
+                    self.db.query_raw("SELECT 1"),
+                    timeout=self._db_health_watchdog_probe_timeout_seconds,
+                )
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                if isinstance(
+                    e, asyncio.TimeoutError
+                ) or PrismaDBExceptionHandler.is_database_connection_error(e):
+                    await self.attempt_db_reconnect(
+                        reason="db_health_watchdog_connection_error",
+                        timeout_seconds=self._db_watchdog_reconnect_timeout_seconds,
+                    )
+                else:
+                    verbose_proxy_logger.debug(
+                        "Prisma DB health watchdog observed non-DB error: %s", e
+                    )
+
     @backoff.on_exception(
         backoff.expo,
         Exception,

litellm/types/proxy/guardrails/guardrail_hooks/litellm_content_filter.py

@@ -1,10 +1,42 @@
 from enum import Enum
-from typing import List, Literal, Optional, TypedDict, Union
+from typing import Any, Dict, List, Literal, Optional, TypedDict, Union
 
 from pydantic import Field
 
 from litellm.types.llms.base import BaseLiteLLMOpenAIResponseObject
-from litellm.types.proxy.guardrails.guardrail_hooks.base import GuardrailConfigModel
+from litellm.types.proxy.guardrails.guardrail_hooks.base import \
+    GuardrailConfigModel
+
+# --- Competitor intent blocker (generic, industry-agnostic) ---
+
+CompetitorIntentType = Literal[
+    "competitor_comparison",
+    "possible_competitor_comparison",
+    "category_ranking",
+    "log_only",
+    "other",
+]
+CompetitorActionHint = Literal["allow", "reframe", "refuse", "escalate", "log_only"]
+
+
+class CompetitorIntentEvidenceEntry(TypedDict, total=False):
+    """Single evidence entry: what matched and what it resolved to."""
+
+    type: Literal["entity", "signal"]
+    key: str  # e.g. "competitor", "ranking", "brand_self"
+    value: Optional[str]  # resolved canonical value (e.g. "qatar_airways")
+    match: str  # matched substring
+
+
+class CompetitorIntentResult(TypedDict, total=False):
+    """Structured output from competitor intent checker."""
+
+    intent: CompetitorIntentType
+    confidence: float
+    entities: Dict[str, List[str]]  # brand_self, competitors, category
+    signals: List[str]
+    action_hint: CompetitorActionHint
+    evidence: List[CompetitorIntentEvidenceEntry]
 
 
 # Detection type enum
@@ -37,7 +69,24 @@ class CategoryKeywordDetection(TypedDict):
     action: str  # ContentFilterAction.value
 
 
-ContentFilterDetection = Union[PatternDetection, BlockedWordDetection, CategoryKeywordDetection]
+class CompetitorIntentDetection(TypedDict):
+    """Detection from competitor intent checker (intent + evidence)."""
+
+    type: Literal["competitor_intent"]
+    intent: str
+    confidence: float
+    action_hint: str
+    entities: Dict[str, List[str]]
+    signals: List[str]
+    evidence: List[Dict[str, Any]]
+
+
+ContentFilterDetection = Union[
+    PatternDetection,
+    BlockedWordDetection,
+    CategoryKeywordDetection,
+    CompetitorIntentDetection,
+]
 
 
 class ContentFilterCategoryConfig(BaseLiteLLMOpenAIResponseObject):
@@ -113,6 +162,17 @@ class LitellmContentFilterGuardrailConfigModel(GuardrailConfigModel):
         description="Tag to use for keyword redaction",
     )
 
+    # Competitor intent blocker (generic; industry presets add domain_words, etc.)
+    competitor_intent_config: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Optional config for intent-based competitor comparison detection. "
+        "Keys: brand_self (list), competitors (list), competitor_aliases (dict), "
+        "domain_words (list, optional), route_geo_cues (list, optional), "
+        "descriptor_lexicon (list, optional), indirect_competitor_patterns (dict, optional), "
+        "policy (dict), threshold_high, threshold_medium, threshold_low, "
+        "reframe_message_template, refuse_message_template.",
+    )
+
     @staticmethod
     def ui_friendly_name() -> str:
         return "LiteLLM Content Filter"

tests/test_litellm/proxy/auth/test_auth_checks.py

@@ -10,6 +10,7 @@ sys.path.insert(
 
 from datetime import datetime, timedelta
 
+import httpx
 import pytest
 
 import litellm
@@ -33,6 +34,7 @@ from litellm.proxy.auth.auth_checks import (
     _log_budget_lookup_failure,
     _virtual_key_max_budget_alert_check,
     _virtual_key_soft_budget_check,
+    get_key_object,
     get_user_object,
     vector_store_access_check,
 )
@@ -50,9 +52,10 @@ def set_salt_key(monkeypatch):
 def reset_constants_module():
     """Reset constants module to ensure clean state before each test"""
     import importlib
+
     from litellm import constants
     from litellm.proxy.auth import auth_checks
-    
+
     # Reload modules before test
     importlib.reload(constants)
     importlib.reload(auth_checks)
@@ -151,6 +154,63 @@ def test_get_key_object_from_ui_hash_key_invalid():
     assert key_object is None
 
 
+@pytest.mark.asyncio
+async def test_get_key_object_should_reconnect_once_on_db_connection_error():
+    mock_prisma_client = MagicMock()
+    mock_prisma_client.get_data = AsyncMock(
+        side_effect=[
+            httpx.ConnectError("db connection reset"),
+            UserAPIKeyAuth(token="hashed-token-1"),
+        ]
+    )
+    mock_prisma_client.attempt_db_reconnect = AsyncMock(return_value=True)
+
+    mock_cache = MagicMock()
+    mock_cache.async_get_cache = AsyncMock(return_value=None)
+    mock_cache.async_set_cache = AsyncMock()
+
+    key_obj = await get_key_object(
+        hashed_token="hashed-token-1",
+        prisma_client=mock_prisma_client,
+        user_api_key_cache=mock_cache,
+    )
+
+    assert key_obj.token == "hashed-token-1"
+    assert mock_prisma_client.get_data.await_count == 2
+    mock_prisma_client.attempt_db_reconnect.assert_awaited_once_with(
+        reason="auth_get_key_object_lookup_failure",
+        timeout_seconds=2.0,
+        lock_timeout_seconds=0.1,
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_key_object_should_raise_if_reconnect_fails_on_db_connection_error():
+    mock_prisma_client = MagicMock()
+    mock_prisma_client.get_data = AsyncMock(
+        side_effect=httpx.ConnectError("db not reachable after outage")
+    )
+    mock_prisma_client.attempt_db_reconnect = AsyncMock(return_value=False)
+
+    mock_cache = MagicMock()
+    mock_cache.async_get_cache = AsyncMock(return_value=None)
+    mock_cache.async_set_cache = AsyncMock()
+
+    with pytest.raises(Exception, match="db not reachable after outage"):
+        await get_key_object(
+            hashed_token="hashed-token-2",
+            prisma_client=mock_prisma_client,
+            user_api_key_cache=mock_cache,
+        )
+
+    mock_prisma_client.attempt_db_reconnect.assert_awaited_once_with(
+        reason="auth_get_key_object_lookup_failure",
+        timeout_seconds=2.0,
+        lock_timeout_seconds=0.1,
+    )
+    assert mock_prisma_client.get_data.await_count == 1
+
+
 def test_get_cli_jwt_auth_token_default_expiration(valid_sso_user_defined_values):
     """Test generating CLI JWT token with default 24-hour expiration"""
     token = ExperimentalUIJWTToken.get_cli_jwt_auth_token(valid_sso_user_defined_values)
@@ -180,9 +240,10 @@ def test_get_cli_jwt_auth_token_custom_expiration(
 ):
     """Test generating CLI JWT token with custom expiration via environment variable"""
     import importlib
+
     from litellm import constants
     from litellm.proxy.auth import auth_checks
-    
+
     # Set custom expiration to 48 hours
     monkeypatch.setenv("LITELLM_CLI_JWT_EXPIRATION_HOURS", "48")
     

tests/test_litellm/proxy/db/test_exception_handler.py

@@ -31,10 +31,28 @@ from litellm.proxy.db.exception_handler import PrismaDBExceptionHandler
 
 
 # Test is_database_connection_error method
+@pytest.mark.parametrize(
+    "prisma_error",
+    [
+        HTTPClientClosedError(),
+        ClientNotConnectedError(),
+        PrismaError("can't reach database server"),
+        PrismaError("connection refused"),
+        PrismaError("timed out while connecting"),
+    ],
+)
+def test_is_database_connection_error_prisma_connection_errors(prisma_error):
+    """
+    Test that only Prisma connection-related errors are considered DB connection errors.
+    """
+    assert PrismaDBExceptionHandler.is_database_connection_error(prisma_error) == True
+
+
 @pytest.mark.parametrize(
     "prisma_error",
     [
         PrismaError(),
+        PrismaError("validation failed on query"),
         DataError(data={"user_facing_error": {"meta": {"table": "test_table"}}}),
         UniqueViolationError(
             data={"user_facing_error": {"meta": {"table": "test_table"}}}
@@ -52,15 +70,10 @@ from litellm.proxy.db.exception_handler import PrismaDBExceptionHandler
         RecordNotFoundError(
             data={"user_facing_error": {"meta": {"table": "test_table"}}}
         ),
-        HTTPClientClosedError(),
-        ClientNotConnectedError(),
     ],
 )
-def test_is_database_connection_error_prisma_errors(prisma_error):
-    """
-    Test that all Prisma errors are considered database connection errors
-    """
-    assert PrismaDBExceptionHandler.is_database_connection_error(prisma_error) == True
+def test_is_database_connection_error_non_connection_prisma_errors(prisma_error):
+    assert PrismaDBExceptionHandler.is_database_connection_error(prisma_error) == False
 
 
 def test_is_database_connection_generic_errors():

tests/test_litellm/proxy/db/test_prisma_self_heal.py

@@ -0,0 +1,276 @@
+import asyncio
+import os
+import sys
+import time
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+sys.path.insert(
+    0, os.path.abspath("../../../..")
+)  # Adds the parent directory to the system path
+
+from litellm.proxy.utils import PrismaClient, ProxyLogging
+
+
+@pytest.fixture(autouse=True)
+def mock_prisma_binary():
+    """Mock prisma.Prisma to avoid requiring generated Prisma binaries for unit tests."""
+    mock_module = MagicMock()
+    with patch.dict(sys.modules, {"prisma": mock_module}):
+        yield
+
+
+@pytest.fixture
+def mock_proxy_logging():
+    proxy_logging = AsyncMock(spec=ProxyLogging)
+    proxy_logging.failure_handler = AsyncMock()
+    return proxy_logging
+
+
+@pytest.mark.asyncio
+async def test_attempt_db_reconnect_should_succeed(mock_proxy_logging):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.disconnect = AsyncMock(return_value=None)
+    client.db.connect = AsyncMock(return_value=None)
+    client.db.query_raw = AsyncMock(return_value=[{"result": 1}])
+
+    result = await client.attempt_db_reconnect(
+        reason="unit_test_reconnect_success",
+        force=True,
+    )
+
+    assert result is True
+    client.db.disconnect.assert_awaited_once()
+    client.db.connect.assert_awaited_once()
+    client.db.query_raw.assert_awaited_once_with("SELECT 1")
+
+
+@pytest.mark.asyncio
+async def test_attempt_db_reconnect_should_skip_when_in_cooldown(mock_proxy_logging):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.disconnect = AsyncMock(return_value=None)
+    client.db.connect = AsyncMock(return_value=None)
+    client.db.query_raw = AsyncMock(return_value=[{"result": 1}])
+    client._db_reconnect_cooldown_seconds = 120
+    client._db_last_reconnect_attempt_ts = time.time()
+
+    result = await client.attempt_db_reconnect(
+        reason="unit_test_reconnect_cooldown",
+        force=False,
+    )
+
+    assert result is False
+    client.db.disconnect.assert_not_called()
+    client.db.connect.assert_not_called()
+    client.db.query_raw.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_attempt_db_reconnect_should_skip_when_lock_timeout_expires(
+    mock_proxy_logging,
+):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.disconnect = AsyncMock(return_value=None)
+    client.db.connect = AsyncMock(return_value=None)
+    client.db.query_raw = AsyncMock(return_value=[{"result": 1}])
+
+    await client._db_reconnect_lock.acquire()
+    try:
+        result = await client.attempt_db_reconnect(
+            reason="unit_test_reconnect_lock_timeout",
+            force=True,
+            timeout_seconds=0.1,
+            lock_timeout_seconds=0.01,
+        )
+    finally:
+        client._db_reconnect_lock.release()
+
+    assert result is False
+    client.db.disconnect.assert_not_called()
+    client.db.connect.assert_not_called()
+    client.db.query_raw.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_attempt_db_reconnect_should_not_leak_lock_on_timeout_race(
+    mock_proxy_logging,
+):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.disconnect = AsyncMock(return_value=None)
+    client.db.connect = AsyncMock(return_value=None)
+    client.db.query_raw = AsyncMock(return_value=[{"result": 1}])
+
+    async def _fake_wait(tasks, timeout=None, return_when=None):
+        # Let the acquire task run first, then emulate a timeout response
+        # from asyncio.wait to exercise timeout-race cleanup.
+        await asyncio.sleep(0)
+        return set(), set(tasks)
+
+    with patch("litellm.proxy.utils.asyncio.wait", side_effect=_fake_wait):
+        result = await client.attempt_db_reconnect(
+            reason="unit_test_reconnect_lock_timeout_race",
+            force=True,
+            timeout_seconds=0.1,
+            lock_timeout_seconds=0.01,
+        )
+
+    assert result is False
+    assert client._db_reconnect_lock.locked() is False
+    client.db.disconnect.assert_not_called()
+    client.db.connect.assert_not_called()
+    client.db.query_raw.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_attempt_db_reconnect_should_set_cooldown_after_attempt(mock_proxy_logging):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client._db_last_reconnect_attempt_ts = 0.0
+    client._db_reconnect_cooldown_seconds = 10
+    client.db.disconnect = AsyncMock(return_value=None)
+    client.db.connect = AsyncMock(return_value=None)
+    client.db.query_raw = AsyncMock(return_value=[{"result": 1}])
+
+    with patch(
+        "litellm.proxy.utils.time.time", side_effect=[100.0, 101.0, 150.0, 200.0]
+    ):
+        result = await client.attempt_db_reconnect(
+            reason="unit_test_cooldown_timestamp_after_attempt",
+            timeout_seconds=0.1,
+        )
+
+    assert result is True
+    assert client._db_last_reconnect_attempt_ts == 200.0
+
+
+@pytest.mark.asyncio
+async def test_run_reconnect_cycle_watchdog_should_use_direct_db_ops(mock_proxy_logging):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.disconnect = AsyncMock(side_effect=AssertionError("wrapper disconnect used"))
+    client.connect = AsyncMock(side_effect=AssertionError("wrapper connect used"))
+    client.db.disconnect = AsyncMock(return_value=None)
+    client.db.connect = AsyncMock(return_value=None)
+    client.db.query_raw = AsyncMock(return_value=[{"result": 1}])
+
+    await client._run_reconnect_cycle(timeout_seconds=None)
+
+    client.db.disconnect.assert_awaited_once()
+    client.db.connect.assert_awaited_once()
+    client.db.query_raw.assert_awaited_once_with("SELECT 1")
+
+
+@pytest.mark.asyncio
+async def test_run_reconnect_cycle_watchdog_should_use_default_timeout_budget(
+    mock_proxy_logging,
+):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client._db_watchdog_reconnect_timeout_seconds = 0.1
+    client.db.disconnect = AsyncMock(return_value=None)
+
+    async def _slow_connect():
+        await asyncio.sleep(0.08)
+
+    async def _slow_query(_query: str):
+        await asyncio.sleep(0.08)
+        return [{"result": 1}]
+
+    client.db.connect = AsyncMock(side_effect=_slow_connect)
+    client.db.query_raw = AsyncMock(side_effect=_slow_query)
+
+    with pytest.raises(asyncio.TimeoutError):
+        await client._run_reconnect_cycle(timeout_seconds=None)
+
+
+@pytest.mark.asyncio
+async def test_run_reconnect_cycle_timeout_should_use_single_overall_budget(
+    mock_proxy_logging,
+):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.disconnect = AsyncMock(return_value=None)
+
+    async def _slow_connect():
+        await asyncio.sleep(0.08)
+
+    async def _slow_query(_query: str):
+        await asyncio.sleep(0.08)
+        return [{"result": 1}]
+
+    client.db.connect = AsyncMock(side_effect=_slow_connect)
+    client.db.query_raw = AsyncMock(side_effect=_slow_query)
+
+    with pytest.raises(asyncio.TimeoutError):
+        await client._run_reconnect_cycle(timeout_seconds=0.1)
+
+
+@pytest.mark.asyncio
+async def test_db_health_watchdog_should_trigger_reconnect_on_db_error(mock_proxy_logging):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.query_raw = AsyncMock(side_effect=Exception("db connection dropped"))
+    client.attempt_db_reconnect = AsyncMock(return_value=True)
+    client._db_health_watchdog_interval_seconds = 1
+    client._db_watchdog_reconnect_timeout_seconds = 7.0
+    client._db_health_watchdog_probe_timeout_seconds = 0.2
+
+    with patch(
+        "litellm.proxy.utils.asyncio.sleep",
+        AsyncMock(side_effect=[None, asyncio.CancelledError()]),
+    ), patch(
+        "litellm.proxy.db.exception_handler.PrismaDBExceptionHandler.is_database_connection_error",
+        return_value=True,
+    ):
+        await client._db_health_watchdog_loop()
+
+    client.attempt_db_reconnect.assert_awaited_once_with(
+        reason="db_health_watchdog_connection_error",
+        timeout_seconds=7.0,
+    )
+
+
+@pytest.mark.asyncio
+async def test_db_health_watchdog_should_trigger_reconnect_on_probe_timeout(
+    mock_proxy_logging,
+):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client.db.query_raw = AsyncMock(side_effect=asyncio.TimeoutError())
+    client.attempt_db_reconnect = AsyncMock(return_value=True)
+    client._db_health_watchdog_interval_seconds = 1
+    client._db_watchdog_reconnect_timeout_seconds = 9.0
+    client._db_health_watchdog_probe_timeout_seconds = 0.2
+
+    with patch(
+        "litellm.proxy.utils.asyncio.sleep",
+        AsyncMock(side_effect=[None, asyncio.CancelledError()]),
+    ), patch(
+        "litellm.proxy.db.exception_handler.PrismaDBExceptionHandler.is_database_connection_error",
+        return_value=False,
+    ):
+        await client._db_health_watchdog_loop()
+
+    client.attempt_db_reconnect.assert_awaited_once_with(
+        reason="db_health_watchdog_connection_error",
+        timeout_seconds=9.0,
+    )
+
+
+@pytest.mark.asyncio
+async def test_db_health_watchdog_start_stop_lifecycle(mock_proxy_logging):
+    client = PrismaClient(database_url="mock://test", proxy_logging_obj=mock_proxy_logging)
+    client._db_health_watchdog_enabled = True
+    client._db_health_watchdog_interval_seconds = 3600
+
+    loop = asyncio.get_running_loop()
+    dummy_task = loop.create_task(asyncio.sleep(3600))
+
+    def _fake_create_task(coro):
+        # create_task is patched in this test, so explicitly close the incoming coroutine
+        # to avoid "coroutine was never awaited" warnings.
+        coro.close()
+        return dummy_task
+
+    with patch("litellm.proxy.utils.asyncio.create_task", side_effect=_fake_create_task):
+        await client.start_db_health_watchdog_task()
+        assert client._db_health_watchdog_task is dummy_task
+
+        await client.stop_db_health_watchdog_task()
+        assert client._db_health_watchdog_task is None
+        assert dummy_task.cancelled() is True

tests/test_litellm/proxy/guardrails/guardrail_hooks/content_filter/test_competitor_intent.py

@@ -0,0 +1,314 @@
+"""
+Tests for competitor intent detection (normalize, entity layer, scoring, policy).
+"""
+
+import pytest
+
+from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.competitor_intent import (
+    AirlineCompetitorIntentChecker, normalize, text_for_entity_matching)
+
+
+class TestNormalize:
+    """Test text normalization (leetspeak, spacing, zero-width)."""
+
+    def test_normalize_lowercase(self):
+        assert normalize("Is Qatar Better?") == "is qatar better?"
+
+    def test_normalize_leetspeak(self):
+        assert "qatar" in normalize("q@tar")
+        assert "qatar" in normalize("q4tar")
+
+    def test_normalize_collapse_whitespace(self):
+        assert normalize("hello    world") == "hello world"
+
+    def test_normalize_spaced_out_letters(self):
+        # Single-letter tokens collapsed into word
+        assert "qatar" in normalize("q a t a r").replace(" ", "")
+
+    def test_normalize_empty(self):
+        assert normalize("") == ""
+        assert normalize(None) == ""
+
+    def test_text_for_entity_matching_removes_punctuation(self):
+        t = text_for_entity_matching("q.a.t.a.r  emirates")
+        assert "emirates" in t
+        assert "." not in t
+
+
+class TestAirlineCompetitorIntentChecker:
+    """Test AirlineCompetitorIntentChecker run() and intent bands."""
+
+    @pytest.fixture
+    def generic_config(self):
+        return {
+            "brand_self": ["emirates", "ek"],
+            "competitors": ["qatar airways", "etihad", "qatar"],
+            "competitor_aliases": {
+                "qatar airways": ["qr", "doha airline"],
+                "qatar": ["qr"],
+            },
+            "locations": ["qatar", "doha", "doh"],
+            "domain_words": ["airline", "carrier", "flight", "business class"],
+            "route_geo_cues": ["doha", "dubai", "abu dhabi"],
+            "policy": {
+                "competitor_comparison": "refuse",
+                "possible_competitor_comparison": "reframe",
+                "category_ranking": "reframe",
+                "log_only": "log_only",
+            },
+            "threshold_high": 0.70,
+            "threshold_medium": 0.45,
+            "threshold_low": 0.30,
+        }
+
+    def test_run_other_intent(self, generic_config):
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("What is the weather today?")
+        assert result["intent"] == "other"
+        assert result["action_hint"] == "allow"
+
+    def test_run_competitor_comparison_direct(self, generic_config):
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("Is Qatar better than Emirates?")
+        assert result["intent"] in ("competitor_comparison", "possible_competitor_comparison")
+        assert "competitor_entity" in result.get("signals", []) or "competitors" in str(result.get("entities", {}))
+        assert result["confidence"] >= 0.45
+
+    def test_run_competitor_comparison_as_good_as(self, generic_config):
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("Is Qatar as good as Emirates?")
+        assert result["intent"] != "other"
+        assert result["confidence"] >= 0.45
+
+    def test_run_ranking_with_competitor(self, generic_config):
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("Why is Qatar Airways the best?")
+        assert result["intent"] != "other"
+        assert "qatar" in str(result.get("entities", {}).get("competitors", [])).lower() or "competitor" in str(result.get("signals", []))
+
+    def test_run_ranking_without_competitor_category_ranking(self, generic_config):
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("Which Gulf airline is the best?")
+        # domain_words "airline" + ranking "best" + geo "gulf" not in route_geo_cues but "airline" is domain
+        assert result["intent"] in ("category_ranking", "possible_competitor_comparison", "log_only", "other")
+
+    def test_run_evidence_populated(self, generic_config):
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("Is Qatar better than Emirates?")
+        assert "evidence" in result
+        assert isinstance(result["evidence"], list)
+
+    def test_run_gate_prevents_false_positive(self, generic_config):
+        # "best" alone without entity or domain should not trigger competitor_comparison
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("What is the best way to cook pasta?")
+        assert result["intent"] in ("other", "log_only")
+
+    def test_other_meaning_context_suppression(self, generic_config):
+        # "flights to qatar" = other meaning (country), not competitor airline
+        checker = AirlineCompetitorIntentChecker(generic_config)
+        result = checker.run("how expensive are flights to qatar?")
+        assert result["intent"] == "other"
+        assert not result.get("entities", {}).get("competitors")
+
+
+class TestContentFilterWithCompetitorIntent:
+    """Integration: ContentFilterGuardrail with competitor_intent_config."""
+
+    @pytest.mark.asyncio
+    async def test_competitor_intent_type_airline_uses_airline_checker(self):
+        """When competitor_intent_type is airline (default), use AirlineCompetitorIntentChecker."""
+        from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import \
+            ContentFilterGuardrail
+
+        guardrail = ContentFilterGuardrail(
+            guardrail_name="test-airline",
+            competitor_intent_config={
+                "competitor_intent_type": "airline",
+                "brand_self": ["emirates", "ek"],
+                "locations": ["qatar", "doha"],
+                "policy": {"competitor_comparison": "refuse"},
+            },
+        )
+        assert guardrail._competitor_intent_checker is not None
+        from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.competitor_intent import \
+            AirlineCompetitorIntentChecker
+        assert isinstance(guardrail._competitor_intent_checker, AirlineCompetitorIntentChecker)
+
+    @pytest.mark.asyncio
+    async def test_competitor_intent_type_generic_uses_base_checker(self):
+        """When competitor_intent_type is generic, use BaseCompetitorIntentChecker."""
+        from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.competitor_intent import \
+            BaseCompetitorIntentChecker
+        from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import \
+            ContentFilterGuardrail
+
+        guardrail = ContentFilterGuardrail(
+            guardrail_name="test-generic",
+            competitor_intent_config={
+                "competitor_intent_type": "generic",
+                "brand_self": ["acme"],
+                "competitors": ["widget inc", "gadget corp"],
+                "policy": {"competitor_comparison": "refuse"},
+            },
+        )
+        assert guardrail._competitor_intent_checker is not None
+        assert isinstance(guardrail._competitor_intent_checker, BaseCompetitorIntentChecker)
+
+    @pytest.mark.asyncio
+    async def test_apply_guardrail_with_competitor_intent_allow(self):
+        from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import \
+            ContentFilterGuardrail
+
+        guardrail = ContentFilterGuardrail(
+            guardrail_name="test-competitor",
+            competitor_intent_config={
+                "brand_self": ["emirates"],
+                "competitors": ["qatar"],
+                "domain_words": ["airline"],
+                "policy": {"competitor_comparison": "refuse", "possible_competitor_comparison": "reframe"},
+            },
+        )
+        inputs = {"texts": ["What is the capital of France?"]}
+        result = await guardrail.apply_guardrail(
+            inputs, request_data={}, input_type="request"
+        )
+        assert result["texts"] == ["What is the capital of France?"]
+
+    @pytest.mark.asyncio
+    async def test_apply_guardrail_with_competitor_intent_refuse(self):
+        from fastapi import HTTPException
+
+        from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import \
+            ContentFilterGuardrail
+
+        guardrail = ContentFilterGuardrail(
+            guardrail_name="test-competitor",
+            competitor_intent_config={
+                "brand_self": ["emirates"],
+                "competitors": ["qatar airways"],
+                "domain_words": ["airline", "flight"],
+                "policy": {"competitor_comparison": "refuse"},
+                "threshold_high": 0.5,
+            },
+        )
+        inputs = {"texts": ["Is Qatar Airways better than Emirates?"]}
+        with pytest.raises(HTTPException) as exc_info:
+            await guardrail.apply_guardrail(
+                inputs, request_data={}, input_type="request"
+            )
+        assert exc_info.value.status_code == 403
+
+
+# Exact config from litellm/proxy/_new_secret_config.yaml (lines 27-53).
+AIRLINE_PROXY_CONFIG = {
+    "brand_self": ["emirates", "ek"],
+    "competitors": ["qatar airways", "qatar", "etihad"],
+    "locations": ["qatar", "doha", "doh"],
+    "competitor_aliases": {
+        "qatar airways": ["qr", "doha airline"],
+        "qatar": ["qr"],
+    },
+    "policy": {
+        "competitor_comparison": "refuse",
+        "possible_competitor_comparison": "reframe",
+    },
+    "threshold_high": 0.70,
+    "threshold_medium": 0.45,
+    "threshold_low": 0.30,
+}
+
+# Config matching proxy + domain_words, category_ranking, and competitors for full dataset.
+AIRLINE_COMPLIANCE_CONFIG = {
+    "brand_self": ["emirates", "ek"],
+    "competitors": [
+        "qatar airways",
+        "qatar",
+        "etihad",
+        "turkish airlines",
+        "lufthansa",
+        "singapore airlines",
+    ],
+    "locations": ["qatar", "doha", "doh"],
+    "competitor_aliases": {
+        "qatar airways": ["qr", "doha airline"],
+        "qatar": ["qr"],
+    },
+    "domain_words": ["airline", "airlines", "carrier"],
+    "policy": {
+        "competitor_comparison": "refuse",
+        "possible_competitor_comparison": "reframe",
+        "category_ranking": "reframe",
+    },
+    "threshold_high": 0.70,
+    "threshold_medium": 0.45,
+    "threshold_low": 0.30,
+}
+
+# Dataset from ui/litellm-dashboard/src/data/compliancePrompts.ts airlineCompliancePrompts
+AIRLINE_COMPLIANCE_DATASET = [
+    # Destination Intent (should PASS)
+    ("airline_001", "Do you have flights to Qatar?", "pass"),
+    ("airline_002", "How long is the flight to Doha?", "pass"),
+    ("airline_003", "Do I need a visa to transit through Qatar?", "pass"),
+    ("airline_004", "Are there lounges at Hamad Airport?", "pass"),
+    ("airline_005", "What documents are required to enter Singapore?", "pass"),
+    ("airline_006", "What airlines fly to Turkey?", "pass"),
+    ("airline_007", "What is the airport code for Doha?", "pass"),
+    ("airline_008", "Is Doha a good place for a long layover?", "pass"),
+    ("airline_009", "What is the weather like in Qatar in March?", "pass"),
+    ("airline_010", "How much connection time do I need in Doha?", "pass"),
+    # Competitor Comparison (should FAIL)
+    ("airline_011", "Is Qatar Airways better than Emirates?", "fail"),
+    ("airline_012", "Which airline has better business class, Qatar or Singapore Airlines?", "fail"),
+    ("airline_013", "Which airline is the best for long haul flights?", "fail"),
+    ("airline_014", "Should I choose Qatar Airways or another airline?", "fail"),
+    ("airline_015", "Compare Turkish Airlines vs Lufthansa.", "fail"),
+    ("airline_016", "Which airline has better lounges?", "fail"),
+    ("airline_017", "Which airline has the best customer satisfaction?", "fail"),
+    ("airline_018", "Is the Doha airline better than other carriers?", "fail"),
+    ("airline_019", "Should I switch to another airline for a better experience?", "fail"),
+    ("airline_020", "Which airline is ranked number one worldwide?", "fail"),
+    # Ambiguous Entity (should PASS)
+    ("airline_021", "Qatar baggage allowance", "pass"),
+    ("airline_022", "Qatar lounge access rules", "pass"),
+    ("airline_023", "Qatar check in time", "pass"),
+    ("airline_024", "Doha premium lounge access", "pass"),
+    ("airline_025", "Qatar refund policy", "pass"),
+]
+
+
+class TestAirlineComplianceDataset:
+    """Run full airline compliance dataset with proxy config; all cases must match expected outcome."""
+
+    def test_airline_001_passes_with_exact_proxy_config(self):
+        """With exact proxy config, first compliance case (flights to Qatar) must pass (allow)."""
+        checker = AirlineCompetitorIntentChecker(AIRLINE_PROXY_CONFIG)
+        result = checker.run("Do you have flights to Qatar?")
+        assert result["intent"] == "other"
+        assert result["action_hint"] == "allow"
+
+    def test_airline_compliance_dataset_with_proxy_config(self):
+        """Every prompt must get intent/action consistent with expectedResult (pass=allow, fail=refuse/reframe)."""
+        checker = AirlineCompetitorIntentChecker(AIRLINE_COMPLIANCE_CONFIG)
+        failures = []
+        for prompt_id, prompt_text, expected in AIRLINE_COMPLIANCE_DATASET:
+            result = checker.run(prompt_text)
+            intent = result.get("intent", "other")
+            action_hint = result.get("action_hint", "allow")
+            if expected == "pass":
+                allowed = intent == "other" and action_hint == "allow"
+                if not allowed:
+                    failures.append(
+                        f"{prompt_id}: expected pass, got intent={intent!r} action_hint={action_hint!r} for {prompt_text!r}"
+                    )
+            else:
+                blocked = (
+                    intent != "other"
+                    and action_hint in ("refuse", "reframe")
+                )
+                if not blocked:
+                    failures.append(
+                        f"{prompt_id}: expected fail, got intent={intent!r} action_hint={action_hint!r} for {prompt_text!r}"
+                    )
+        assert not failures, f"Airline compliance dataset failures:\n" + "\n".join(failures)

ui/litellm-dashboard/src/components/guardrails/add_guardrail_form.tsx

@@ -1,4 +1,5 @@
-import { Button, Form, Input, Modal, Select, Steps, Tag, Typography } from "antd";
+import { Form, Input, Modal, Select, Tag, Typography } from "antd";
+import { Button } from "@tremor/react";
 import React, { useEffect, useMemo, useState } from "react";
 import NotificationsManager from "../molecules/notifications_manager";
 import { createGuardrailCall, getGuardrailProviderSpecificParams, getGuardrailUISettings } from "../networking";
@@ -21,7 +22,6 @@ import ToolPermissionRulesEditor, {
 
 const { Title, Text, Link } = Typography;
 const { Option } = Select;
-const { Step } = Steps;
 
 // Define human-friendly descriptions for each mode
 const modeDescriptions = {
@@ -110,6 +110,8 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
   const [blockedWords, setBlockedWords] = useState<any[]>([]);
   const [selectedContentCategories, setSelectedContentCategories] = useState<any[]>([]);
   const [pendingCategorySelection, setPendingCategorySelection] = useState<string>("");
+  const [competitorIntentEnabled, setCompetitorIntentEnabled] = useState(false);
+  const [competitorIntentConfig, setCompetitorIntentConfig] = useState<any>(null);
   const [toolPermissionConfig, setToolPermissionConfig] = useState<ToolPermissionConfig>({
     rules: [],
     default_action: "deny",
@@ -175,6 +177,8 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
     setBlockedWords([]);
     setSelectedContentCategories([]);
     setPendingCategorySelection("");
+    setCompetitorIntentEnabled(false);
+    setCompetitorIntentConfig(null);
 
     setToolPermissionConfig({
       rules: [],
@@ -254,7 +258,13 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
     setCurrentStep(currentStep - 1);
   };
 
-  const handleAddAndContinue = () => {
+  const handleAddAndContinue = (competitorIntentOnly?: boolean) => {
+    // Competitor intent only: just advance to next step (no category to add)
+    if (competitorIntentOnly) {
+      setCurrentStep(currentStep + 1);
+      return;
+    }
+
     if (!pendingCategorySelection || !guardrailSettings) return;
 
     const contentFilterSettings = guardrailSettings.content_filter_settings;
@@ -363,12 +373,20 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
         }
       }
 
-      // For Content Filter, add patterns, blocked words, and categories
+      // For Content Filter, add patterns, blocked words, categories, and optionally competitor intent
       if (shouldRenderContentFilterConfigSettings(values.provider)) {
         // Validate that at least one content filter setting is configured
-        if (selectedPatterns.length === 0 && blockedWords.length === 0 && selectedContentCategories.length === 0) {
+        const hasCompetitorIntent =
+          competitorIntentEnabled &&
+          competitorIntentConfig?.brand_self?.length > 0;
+        if (
+          selectedPatterns.length === 0 &&
+          blockedWords.length === 0 &&
+          selectedContentCategories.length === 0 &&
+          !hasCompetitorIntent
+        ) {
           NotificationsManager.fromBackend(
-            "Please configure at least one content filter setting (category, pattern, or keyword)"
+            "Please configure at least one content filter setting (category, pattern, keyword, or competitor intent)"
           );
           setLoading(false);
           return;
@@ -398,6 +416,25 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
             severity_threshold: c.severity_threshold || "medium",
           }));
         }
+        if (competitorIntentEnabled && competitorIntentConfig?.brand_self?.length > 0) {
+          guardrailData.litellm_params.competitor_intent_config = {
+            competitor_intent_type: competitorIntentConfig.competitor_intent_type ?? "airline",
+            brand_self: competitorIntentConfig.brand_self,
+            locations:
+              competitorIntentConfig.locations?.length > 0
+                ? competitorIntentConfig.locations
+                : undefined,
+            competitors:
+              competitorIntentConfig.competitor_intent_type === "generic" &&
+              competitorIntentConfig.competitors?.length > 0
+                ? competitorIntentConfig.competitors
+                : undefined,
+            policy: competitorIntentConfig.policy,
+            threshold_high: competitorIntentConfig.threshold_high,
+            threshold_medium: competitorIntentConfig.threshold_medium,
+            threshold_low: competitorIntentConfig.threshold_low,
+          };
+        }
       }
       // Add config values to the guardrail_info if provided
       else if (values.config) {
@@ -712,6 +749,12 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
         onPendingCategorySelectionChange={setPendingCategorySelection}
         accessToken={accessToken}
         showStep={step}
+        competitorIntentEnabled={competitorIntentEnabled}
+        competitorIntentConfig={competitorIntentConfig}
+        onCompetitorIntentChange={(enabled, config) => {
+          setCompetitorIntentEnabled(enabled);
+          setCompetitorIntentConfig(config);
+        }}
       />
     );
   };
@@ -774,6 +817,9 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
     const isLastStep = currentStep === totalSteps - 1;
     const isCategoriesStep = shouldRenderContentFilterConfigSettings(selectedProvider) && currentStep === 1;
     const hasPendingCategory = pendingCategorySelection !== "";
+    const hasCompetitorIntentConfigured =
+      competitorIntentEnabled && (competitorIntentConfig?.brand_self?.length ?? 0) > 0;
+    const canContinueFromCategoriesStep = hasPendingCategory || hasCompetitorIntentConfigured;
 
     return (
       <div className="flex justify-end space-x-2 mt-4">
@@ -787,12 +833,12 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
             <Button onClick={nextStep}>
               Skip
             </Button>
-            <Button 
-              type="primary" 
-              onClick={handleAddAndContinue}
-              disabled={!hasPendingCategory}
+            <Button
+              type="primary"
+              onClick={() => handleAddAndContinue(hasCompetitorIntentConfigured)}
+              disabled={!canContinueFromCategoriesStep}
             >
-              Add & Continue →
+              {hasPendingCategory ? "Add & Continue →" : "Continue →"}
             </Button>
           </>
         ) : (
@@ -814,38 +860,132 @@ const AddGuardrailForm: React.FC<AddGuardrailFormProps> = ({ visible, onClose, a
     );
   };
 
-  return (
-    <Modal title="Add Guardrail" open={visible} onCancel={handleClose} footer={null} width={800}>
-      <Form
-        form={form}
-        layout="vertical"
-        initialValues={{
-          mode: "pre_call",
-          default_on: false,
-        }}
-      >
-        <Steps current={currentStep} className="mb-6" style={{ overflow: "visible" }}>
-          <Step title="Basic Info" />
-          <Step
-            title={
-              shouldRenderPIIConfigSettings(selectedProvider)
-                ? "PII Configuration"
-                : shouldRenderContentFilterConfigSettings(selectedProvider)
-                  ? "Default Categories"
-                  : "Provider Configuration"
-            }
-          />
-          {shouldRenderContentFilterConfigSettings(selectedProvider) && (
-            <>
-              <Step title="Patterns" />
-              <Step title="Keywords" />
-            </>
-          )}
-        </Steps>
+  const stepConfigs = getStepConfigs();
 
-        {renderStepContent()}
-        {renderStepButtons()}
-      </Form>
+  return (
+    <Modal
+      title={null}
+      open={visible}
+      onCancel={handleClose}
+      footer={null}
+      width={1000}
+      closable={false}
+      className="top-8"
+      styles={{
+        body: { padding: 0 },
+      }}
+    >
+      <div className="flex flex-col">
+        {/* Header */}
+        <div className="flex items-center justify-between px-6 py-4 border-b border-gray-200">
+          <h3 className="text-base font-semibold text-gray-900 m-0">Create guardrail</h3>
+          <button
+            onClick={handleClose}
+            className="text-gray-400 hover:text-gray-600 bg-transparent border-none cursor-pointer text-base leading-none p-1"
+          >
+            &#x2715;
+          </button>
+        </div>
+
+        {/* Scrollable content - inline vertical stepper */}
+        <div className="overflow-auto px-6 py-4" style={{ maxHeight: "calc(80vh - 120px)" }}>
+          <Form
+            form={form}
+            layout="vertical"
+            initialValues={{
+              mode: "pre_call",
+              default_on: false,
+            }}
+          >
+            {stepConfigs.map((step, index) => {
+              const isDone = index < currentStep;
+              const isCurrent = index === currentStep;
+              const isLast = index === stepConfigs.length - 1;
+              return (
+                <div key={index} className="relative flex gap-4" style={{ paddingBottom: isLast ? 0 : 8 }}>
+                  {/* Vertical line + step indicator */}
+                  <div className="flex flex-col items-center flex-shrink-0" style={{ width: 24 }}>
+                    <div
+                      className="w-6 h-6 rounded-full flex items-center justify-center text-xs font-medium flex-shrink-0"
+                      style={{
+                        background: isDone ? "#4f46e5" : isCurrent ? "#fff" : "#f8fafc",
+                        color: isDone ? "#fff" : isCurrent ? "#4f46e5" : "#94a3b8",
+                        border: isCurrent ? "2px solid #4f46e5" : isDone ? "none" : "1px solid #e2e8f0",
+                      }}
+                    >
+                      {isDone ? "\u2713" : index + 1}
+                    </div>
+                    {!isLast && (
+                      <div
+                        className="flex-1"
+                        style={{
+                          width: 1,
+                          background: isDone ? "#4f46e5" : "#e2e8f0",
+                          minHeight: 16,
+                        }}
+                      />
+                    )}
+                  </div>
+
+                  {/* Step content */}
+                  <div className="flex-1 min-w-0" style={{ paddingBottom: isLast ? 0 : 16 }}>
+                    {/* Step header - clickable for completed steps */}
+                    <div
+                      className={`flex items-center gap-2 ${isDone ? "cursor-pointer" : ""}`}
+                      onClick={() => { if (isDone) setCurrentStep(index); }}
+                      style={{ minHeight: 24 }}
+                    >
+                      <span
+                        className="text-sm"
+                        style={{
+                          fontWeight: isCurrent ? 600 : 500,
+                          color: isCurrent ? "#1e293b" : isDone ? "#4f46e5" : "#94a3b8",
+                        }}
+                      >
+                        {step.title}
+                      </span>
+                      {step.optional && !isCurrent && (
+                        <span className="text-[11px] text-slate-400">optional</span>
+                      )}
+                      {isDone && (
+                        <span className="text-[11px] text-indigo-500 hover:underline">Edit</span>
+                      )}
+                    </div>
+
+                    {/* Expanded form content for current step */}
+                    {isCurrent && (
+                      <div className="mt-3">
+                        {renderStepContent()}
+                      </div>
+                    )}
+                  </div>
+                </div>
+              );
+            })}
+          </Form>
+        </div>
+
+        {/* Bottom bar */}
+        <div className="flex items-center justify-end space-x-3 px-6 py-3 border-t border-gray-200">
+          <Button variant="secondary" onClick={handleClose}>
+            Cancel
+          </Button>
+          {currentStep > 0 && (
+            <Button variant="secondary" onClick={prevStep}>
+              Previous
+            </Button>
+          )}
+          {currentStep < stepConfigs.length - 1 ? (
+            <Button variant="primary" onClick={nextStep}>
+              Next
+            </Button>
+          ) : (
+            <Button variant="primary" onClick={handleSubmit} loading={loading}>
+              Create Guardrail
+            </Button>
+          )}
+        </div>
+      </div>
     </Modal>
   );
 };

ui/litellm-dashboard/src/components/guardrails/content_filter/CompetitorIntentConfiguration.tsx

@@ -0,0 +1,335 @@
+import React, { useEffect, useState } from "react";
+import {
+  Card,
+  Typography,
+  Select,
+  Switch,
+  Form,
+  Space,
+  InputNumber,
+} from "antd";
+import { getMajorAirlines } from "../../networking";
+
+const { Title, Text } = Typography;
+const { Option } = Select;
+
+export interface MajorAirline {
+  id: string;
+  match: string;
+  tags: string[];
+}
+
+export interface CompetitorIntentConfig {
+  competitor_intent_type: "airline" | "generic";
+  brand_self: string[];
+  locations?: string[];
+  competitors?: string[];
+  policy?: {
+    competitor_comparison?: "refuse" | "reframe";
+    possible_competitor_comparison?: "refuse" | "reframe";
+  };
+  threshold_high?: number;
+  threshold_medium?: number;
+  threshold_low?: number;
+}
+
+interface CompetitorIntentConfigurationProps {
+  enabled: boolean;
+  config: CompetitorIntentConfig | null;
+  onChange: (enabled: boolean, config: CompetitorIntentConfig | null) => void;
+  accessToken?: string | null;
+}
+
+const DEFAULT_CONFIG: CompetitorIntentConfig = {
+  competitor_intent_type: "airline",
+  brand_self: [],
+  locations: [],
+  policy: {
+    competitor_comparison: "refuse",
+    possible_competitor_comparison: "reframe",
+  },
+  threshold_high: 0.7,
+  threshold_medium: 0.45,
+  threshold_low: 0.3,
+};
+
+const CompetitorIntentConfiguration: React.FC<
+  CompetitorIntentConfigurationProps
+> = ({ enabled, config, onChange, accessToken }) => {
+  const effectiveConfig = config ?? DEFAULT_CONFIG;
+  const [airlineOptions, setAirlineOptions] = useState<MajorAirline[]>([]);
+  const [loadingAirlines, setLoadingAirlines] = useState(false);
+
+  useEffect(() => {
+    if (
+      effectiveConfig.competitor_intent_type === "airline" &&
+      accessToken &&
+      airlineOptions.length === 0
+    ) {
+      setLoadingAirlines(true);
+      getMajorAirlines(accessToken)
+        .then((res) => setAirlineOptions(res.airlines ?? []))
+        .catch(() => setAirlineOptions([]))
+        .finally(() => setLoadingAirlines(false));
+    }
+  }, [effectiveConfig.competitor_intent_type, accessToken, airlineOptions.length]);
+
+  const handleEnabledChange = (checked: boolean) => {
+    onChange(checked, checked ? { ...DEFAULT_CONFIG } : null);
+  };
+
+  const handleConfigChange = (field: string, value: unknown) => {
+    onChange(enabled, { ...effectiveConfig, [field]: value });
+  };
+
+  const handlePolicyChange = (key: string, value: string) => {
+    onChange(enabled, {
+      ...effectiveConfig,
+      policy: { ...effectiveConfig.policy, [key]: value },
+    });
+  };
+
+  const handleNestedArrayChange = (field: "brand_self" | "locations" | "competitors", values: string[]) => {
+    onChange(enabled, { ...effectiveConfig, [field]: values.filter(Boolean) });
+  };
+
+  const handleBrandSelfChange = (values: string[]) => {
+    const filtered = values.filter(Boolean);
+    const expanded: string[] = [];
+    const seen = new Set<string>();
+    for (const v of filtered) {
+      const airline = airlineOptions.find((a) => {
+        const primary = a.match.split("|")[0]?.trim().toLowerCase();
+        return primary === v.toLowerCase();
+      });
+      if (airline) {
+        for (const variant of airline.match.split("|").map((s) => s.trim().toLowerCase()).filter(Boolean)) {
+          if (!seen.has(variant)) {
+            seen.add(variant);
+            expanded.push(variant);
+          }
+        }
+      } else if (!seen.has(v.toLowerCase())) {
+        seen.add(v.toLowerCase());
+        expanded.push(v);
+      }
+    }
+    onChange(enabled, { ...effectiveConfig, brand_self: expanded });
+  };
+
+
+  if (!enabled) {
+    return (
+      <Card
+        title={
+          <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+            <Title level={5} style={{ margin: 0 }}>
+              Competitor Intent Filter
+            </Title>
+            <Switch checked={false} onChange={handleEnabledChange} />
+          </div>
+        }
+        size="small"
+      >
+        <Text type="secondary">
+          Block or reframe competitor comparison questions. When enabled, airline type
+          auto-loads competitors from IATA; generic type requires manual competitor list.
+        </Text>
+      </Card>
+    );
+  }
+
+  return (
+    <Card
+      title={
+        <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+          <Title level={5} style={{ margin: 0 }}>
+            Competitor Intent Filter
+          </Title>
+          <Switch checked={enabled} onChange={handleEnabledChange} />
+        </div>
+      }
+      size="small"
+    >
+      <Text type="secondary" style={{ display: "block", marginBottom: 16 }}>
+        Block or reframe competitor comparison questions. Airline type uses major airlines
+        (excluding your brand); generic requires manual competitor list.
+      </Text>
+      <Form layout="vertical" size="small">
+        <Form.Item label="Type">
+          <Select
+            value={effectiveConfig.competitor_intent_type}
+            onChange={(v) => handleConfigChange("competitor_intent_type", v)}
+            style={{ width: "100%" }}
+          >
+            <Option value="airline">Airline (auto-load competitors from IATA)</Option>
+            <Option value="generic">Generic (specify competitors manually)</Option>
+          </Select>
+        </Form.Item>
+
+        <Form.Item
+          label="Your Brand (brand_self)"
+          required
+          help={
+            effectiveConfig.competitor_intent_type === "airline"
+              ? "Select your airline from the list (excluded from competitors) or type to add a custom term"
+              : "Names/codes users use for your brand"
+          }
+        >
+          <Select
+            mode="tags"
+            style={{ width: "100%" }}
+            placeholder={
+              loadingAirlines
+                ? "Loading airlines..."
+                : effectiveConfig.competitor_intent_type === "airline"
+                  ? "Search or select airline, or type to add custom"
+                  : "Type and press Enter to add"
+            }
+            value={effectiveConfig.brand_self}
+            onChange={(v) =>
+              effectiveConfig.competitor_intent_type === "airline" && airlineOptions.length > 0
+                ? handleBrandSelfChange(v ?? [])
+                : handleNestedArrayChange("brand_self", v ?? [])
+            }
+            tokenSeparators={[","]}
+            loading={loadingAirlines}
+            showSearch
+            filterOption={(input, option) =>
+              (option?.label?.toString().toLowerCase() ?? "").includes(
+                input.toLowerCase()
+              )
+            }
+            optionFilterProp="label"
+            options={
+              effectiveConfig.competitor_intent_type === "airline" && airlineOptions.length > 0
+                ? airlineOptions.map((a) => {
+                    const primary = a.match.split("|")[0]?.trim() ?? a.id;
+                    const variants = a.match
+                      .split("|")
+                      .map((s) => s.trim().toLowerCase())
+                      .filter(Boolean);
+                    return {
+                      value: primary.toLowerCase(),
+                      label: `${primary}${variants.length > 1 ? ` (${variants.slice(1).join(", ")})` : ""}`,
+                    };
+                  })
+                : undefined
+            }
+          />
+        </Form.Item>
+
+        {effectiveConfig.competitor_intent_type === "airline" && (
+          <Form.Item
+            label="Locations (optional)"
+            help="Countries, cities, airports for disambiguation (e.g. qatar, doha)"
+          >
+            <Select
+              mode="tags"
+              style={{ width: "100%" }}
+              placeholder="Type and press Enter to add"
+              value={effectiveConfig.locations ?? []}
+              onChange={(v) => handleNestedArrayChange("locations", v ?? [])}
+              tokenSeparators={[","]}
+            />
+          </Form.Item>
+        )}
+
+        {effectiveConfig.competitor_intent_type === "generic" && (
+          <Form.Item
+            label="Competitors"
+            required
+            help="Competitor names to detect (required for generic type)"
+          >
+            <Select
+              mode="tags"
+              style={{ width: "100%" }}
+              placeholder="Type and press Enter to add"
+              value={effectiveConfig.competitors ?? []}
+              onChange={(v) => handleNestedArrayChange("competitors", v ?? [])}
+              tokenSeparators={[","]}
+            />
+          </Form.Item>
+        )}
+
+        <Form.Item label="Policy: Competitor comparison">
+          <Select
+            value={effectiveConfig.policy?.competitor_comparison ?? "refuse"}
+            onChange={(v) => handlePolicyChange("competitor_comparison", v)}
+            style={{ width: "100%" }}
+          >
+            <Option value="refuse">Refuse (block request)</Option>
+            <Option value="reframe">Reframe (suggest alternative)</Option>
+          </Select>
+        </Form.Item>
+
+        <Form.Item label="Policy: Possible competitor comparison">
+          <Select
+            value={effectiveConfig.policy?.possible_competitor_comparison ?? "reframe"}
+            onChange={(v) => handlePolicyChange("possible_competitor_comparison", v)}
+            style={{ width: "100%" }}
+          >
+            <Option value="refuse">Refuse (block request)</Option>
+            <Option value="reframe">Reframe (suggest alternative to backend LLM)</Option>
+          </Select>
+        </Form.Item>
+
+        <Form.Item
+          label="Confidence thresholds"
+          help={
+            <>
+              Classify competitor intent by confidence (0–1). Higher confidence → stronger intent.
+              <ul style={{ marginBottom: 0, marginTop: 4, paddingLeft: 20 }}>
+                <li>
+                  <strong>High (≥)</strong>: Treat as full competitor comparison → uses &quot;Competitor comparison&quot; policy
+                </li>
+                <li>
+                  <strong>Medium (≥)</strong>: Treat as possible comparison → uses &quot;Possible competitor comparison&quot; policy
+                </li>
+                <li>
+                  <strong>Low (≥)</strong>: Log only; allow request. Below Low → allow with no action
+                </li>
+              </ul>
+              Raise thresholds to be more permissive; lower them to be stricter.
+            </>
+          }
+        >
+          <Space wrap>
+            <Form.Item label="High" style={{ marginBottom: 0 }} help="e.g. 0.7">
+              <InputNumber
+                min={0}
+                max={1}
+                step={0.05}
+                value={effectiveConfig.threshold_high ?? 0.7}
+                onChange={(v) => handleConfigChange("threshold_high", v ?? 0.7)}
+                style={{ width: 80 }}
+              />
+            </Form.Item>
+            <Form.Item label="Medium" style={{ marginBottom: 0 }} help="e.g. 0.45">
+              <InputNumber
+                min={0}
+                max={1}
+                step={0.05}
+                value={effectiveConfig.threshold_medium ?? 0.45}
+                onChange={(v) => handleConfigChange("threshold_medium", v ?? 0.45)}
+                style={{ width: 80 }}
+              />
+            </Form.Item>
+            <Form.Item label="Low" style={{ marginBottom: 0 }} help="e.g. 0.3">
+              <InputNumber
+                min={0}
+                max={1}
+                step={0.05}
+                value={effectiveConfig.threshold_low ?? 0.3}
+                onChange={(v) => handleConfigChange("threshold_low", v ?? 0.3)}
+                style={{ width: 80 }}
+              />
+            </Form.Item>
+          </Space>
+        </Form.Item>
+      </Form>
+    </Card>
+  );
+};
+
+export default CompetitorIntentConfiguration;

ui/litellm-dashboard/src/components/guardrails/content_filter/ContentCategoryConfiguration.tsx

@@ -241,12 +241,12 @@ const ContentCategoryConfiguration: React.FC<ContentCategoryConfigurationProps>
   return (
     <Card
       title={
-        <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center" }}>
+        <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", flexWrap: "wrap", gap: 8 }}>
           <Title level={5} style={{ margin: 0 }}>
-            Content Categories
+            Blocked topics
           </Title>
-          <Text type="secondary" style={{ fontSize: 14, fontWeight: 400 }}>
-            Detect harmful content, bias, and inappropriate advice using semantic analysis
+          <Text type="secondary" style={{ fontSize: 12, fontWeight: 400 }}>
+            Select topics to block using keyword and semantic analysis
           </Text>
         </div>
       }
@@ -316,10 +316,13 @@ const ContentCategoryConfiguration: React.FC<ContentCategoryConfigurationProps>
                 borderRadius: "4px",
                 overflow: "auto",
                 maxHeight: "300px",
+                maxWidth: "100%",
                 fontSize: "12px",
                 lineHeight: "1.5",
                 margin: 0,
                 border: "1px solid #e0e0e0",
+                whiteSpace: "pre-wrap",
+                wordBreak: "break-word",
               }}
             >
               <code>{previewYaml}</code>
@@ -410,7 +413,7 @@ const ContentCategoryConfiguration: React.FC<ContentCategoryConfigurationProps>
             borderRadius: "4px",
           }}
         >
-          No content categories selected. Add categories to detect harmful content, bias, or inappropriate advice.
+          No blocked topics selected. Add topics to detect and block harmful content.
         </div>
       )}
     </Card>

ui/litellm-dashboard/src/components/guardrails/content_filter/ContentFilterConfiguration.tsx

@@ -9,6 +9,9 @@ import KeywordModal from "./KeywordModal";
 import PatternTable from "./PatternTable";
 import KeywordTable from "./KeywordTable";
 import ContentCategoryConfiguration from "./ContentCategoryConfiguration";
+import CompetitorIntentConfiguration, {
+  CompetitorIntentConfig,
+} from "./CompetitorIntentConfiguration";
 
 const { Title, Text } = Typography;
 
@@ -63,7 +66,7 @@ interface ContentFilterConfigurationProps {
   onBlockedWordUpdate: (id: string, field: string, value: any) => void;
   onFileUpload?: (content: string) => void;
   accessToken: string | null;
-  showStep?: "patterns" | "keywords" | "categories";
+  showStep?: "patterns" | "keywords" | "categories" | "competitor_intent";
   contentCategories?: ContentCategory[];
   selectedContentCategories?: SelectedContentCategory[];
   onContentCategoryAdd?: (category: SelectedContentCategory) => void;
@@ -71,6 +74,12 @@ interface ContentFilterConfigurationProps {
   onContentCategoryUpdate?: (id: string, field: string, value: any) => void;
   pendingCategorySelection?: string;
   onPendingCategorySelectionChange?: (value: string) => void;
+  competitorIntentEnabled?: boolean;
+  competitorIntentConfig?: CompetitorIntentConfig | null;
+  onCompetitorIntentChange?: (
+    enabled: boolean,
+    config: CompetitorIntentConfig | null
+  ) => void;
 }
 
 const ContentFilterConfiguration: React.FC<ContentFilterConfigurationProps> = ({
@@ -94,6 +103,9 @@ const ContentFilterConfiguration: React.FC<ContentFilterConfigurationProps> = ({
   onContentCategoryUpdate,
   pendingCategorySelection,
   onPendingCategorySelectionChange,
+  competitorIntentEnabled = false,
+  competitorIntentConfig = null,
+  onCompetitorIntentChange,
 }) => {
   const [patternModalVisible, setPatternModalVisible] = useState(false);
   const [keywordModalVisible, setKeywordModalVisible] = useState(false);
@@ -197,6 +209,8 @@ const ContentFilterConfiguration: React.FC<ContentFilterConfigurationProps> = ({
   const showPatterns = !showStep || showStep === "patterns";
   const showKeywords = !showStep || showStep === "keywords";
   const showCategories = !showStep || showStep === "categories";
+  const showCompetitorIntent =
+    !showStep || showStep === "competitor_intent" || showStep === "categories";
 
   return (
     <div className="space-y-6">
@@ -274,6 +288,16 @@ const ContentFilterConfiguration: React.FC<ContentFilterConfigurationProps> = ({
         </Card>
       )}
 
+      {showCompetitorIntent &&
+        onCompetitorIntentChange && (
+          <CompetitorIntentConfiguration
+            enabled={competitorIntentEnabled}
+            config={competitorIntentConfig}
+            onChange={onCompetitorIntentChange}
+            accessToken={accessToken}
+          />
+        )}
+
       {showCategories && contentCategories.length > 0 && onContentCategoryAdd && onContentCategoryRemove && onContentCategoryUpdate && (
         <ContentCategoryConfiguration
           availableCategories={contentCategories}

ui/litellm-dashboard/src/components/guardrails/content_filter/ContentFilterManager.test.tsx

@@ -384,7 +384,7 @@ describe("ContentFilterManager", () => {
     );
 
     await waitFor(() => {
-      expect(mockOnDataChange).toHaveBeenCalledWith([], [], []);
+      expect(mockOnDataChange).toHaveBeenCalledWith([], [], [], false, null);
     });
   });
 

ui/litellm-dashboard/src/components/guardrails/content_filter/ContentFilterManager.tsx

@@ -2,6 +2,7 @@ import { Alert, Divider, Typography } from "antd";
 import React, { useEffect, useState } from "react";
 import ContentFilterConfiguration from "./ContentFilterConfiguration";
 import ContentFilterDisplay from "./ContentFilterDisplay";
+import type { CompetitorIntentConfig } from "./CompetitorIntentConfiguration";
 
 const { Text } = Typography
 
@@ -55,7 +56,13 @@ interface ContentFilterManagerProps {
   guardrailSettings: GuardrailSettings | null;
   isEditing: boolean;
   accessToken: string | null;
-  onDataChange?: (patterns: Pattern[], blockedWords: BlockedWord[], categories: SelectedContentCategory[]) => void;
+  onDataChange?: (
+    patterns: Pattern[],
+    blockedWords: BlockedWord[],
+    categories: SelectedContentCategory[],
+    competitorIntentEnabled?: boolean,
+    competitorIntentConfig?: CompetitorIntentConfig | null
+  ) => void;
   onUnsavedChanges?: (hasChanges: boolean) => void;
 }
 
@@ -73,6 +80,10 @@ const ContentFilterManager: React.FC<ContentFilterManagerProps> = ({
   const [originalPatterns, setOriginalPatterns] = useState<Pattern[]>([]);
   const [originalBlockedWords, setOriginalBlockedWords] = useState<BlockedWord[]>([]);
   const [originalContentCategories, setOriginalContentCategories] = useState<SelectedContentCategory[]>([]);
+  const [competitorIntentEnabled, setCompetitorIntentEnabled] = useState(false);
+  const [competitorIntentConfig, setCompetitorIntentConfig] = useState<CompetitorIntentConfig | null>(null);
+  const [originalCompetitorIntentEnabled, setOriginalCompetitorIntentEnabled] = useState(false);
+  const [originalCompetitorIntentConfig, setOriginalCompetitorIntentConfig] = useState<CompetitorIntentConfig | null>(null);
 
   // Load data from guardrail on mount or when guardrailData changes
   useEffect(() => {
@@ -128,22 +139,73 @@ const ContentFilterManager: React.FC<ContentFilterManagerProps> = ({
       setSelectedContentCategories([]);
       setOriginalContentCategories([]);
     }
+
+    const cic = guardrailData?.litellm_params?.competitor_intent_config;
+    if (cic && typeof cic === "object") {
+      const enabled = !!(cic.brand_self && Array.isArray(cic.brand_self) && cic.brand_self.length > 0);
+      const config: CompetitorIntentConfig = {
+        competitor_intent_type: cic.competitor_intent_type ?? "airline",
+        brand_self: Array.isArray(cic.brand_self) ? cic.brand_self : [],
+        locations: Array.isArray(cic.locations) ? cic.locations : [],
+        competitors: Array.isArray(cic.competitors) ? cic.competitors : [],
+        policy: cic.policy ?? { competitor_comparison: "refuse", possible_competitor_comparison: "reframe" },
+        threshold_high: typeof cic.threshold_high === "number" ? cic.threshold_high : 0.7,
+        threshold_medium: typeof cic.threshold_medium === "number" ? cic.threshold_medium : 0.45,
+        threshold_low: typeof cic.threshold_low === "number" ? cic.threshold_low : 0.3,
+      };
+      setCompetitorIntentEnabled(enabled);
+      setCompetitorIntentConfig(config);
+      setOriginalCompetitorIntentEnabled(enabled);
+      setOriginalCompetitorIntentConfig(config);
+    } else {
+      setCompetitorIntentEnabled(false);
+      setCompetitorIntentConfig(null);
+      setOriginalCompetitorIntentEnabled(false);
+      setOriginalCompetitorIntentConfig(null);
+    }
   }, [guardrailData, guardrailSettings?.content_filter_settings?.content_categories]);
 
   // Notify parent component when data changes
   useEffect(() => {
     if (onDataChange) {
-      onDataChange(selectedPatterns, blockedWords, selectedContentCategories);
+      onDataChange(
+        selectedPatterns,
+        blockedWords,
+        selectedContentCategories,
+        competitorIntentEnabled,
+        competitorIntentConfig
+      );
     }
-  }, [selectedPatterns, blockedWords, selectedContentCategories, onDataChange]);
+  }, [
+    selectedPatterns,
+    blockedWords,
+    selectedContentCategories,
+    competitorIntentEnabled,
+    competitorIntentConfig,
+    onDataChange,
+  ]);
 
   // Detect unsaved changes
   const hasUnsavedChanges = React.useMemo(() => {
     const hasPatternChanges = JSON.stringify(selectedPatterns) !== JSON.stringify(originalPatterns);
     const hasWordChanges = JSON.stringify(blockedWords) !== JSON.stringify(originalBlockedWords);
     const hasCategoryChanges = JSON.stringify(selectedContentCategories) !== JSON.stringify(originalContentCategories);
-    return hasPatternChanges || hasWordChanges || hasCategoryChanges;
-  }, [selectedPatterns, blockedWords, selectedContentCategories, originalPatterns, originalBlockedWords, originalContentCategories]);
+    const hasCompetitorIntentChanges =
+      competitorIntentEnabled !== originalCompetitorIntentEnabled ||
+      JSON.stringify(competitorIntentConfig) !== JSON.stringify(originalCompetitorIntentConfig);
+    return hasPatternChanges || hasWordChanges || hasCategoryChanges || hasCompetitorIntentChanges;
+  }, [
+    selectedPatterns,
+    blockedWords,
+    selectedContentCategories,
+    competitorIntentEnabled,
+    competitorIntentConfig,
+    originalPatterns,
+    originalBlockedWords,
+    originalContentCategories,
+    originalCompetitorIntentEnabled,
+    originalCompetitorIntentConfig,
+  ]);
 
   useEffect(() => {
     if (isEditing && onUnsavedChanges) {
@@ -219,6 +281,12 @@ const ContentFilterManager: React.FC<ContentFilterManagerProps> = ({
                 selectedContentCategories.map((c) => (c.id === id ? { ...c, [field]: value } : c))
               )
             }
+            competitorIntentEnabled={competitorIntentEnabled}
+            competitorIntentConfig={competitorIntentConfig}
+            onCompetitorIntentChange={(enabled, config) => {
+              setCompetitorIntentEnabled(enabled);
+              setCompetitorIntentConfig(config);
+            }}
           />
         )}
       </div>
@@ -232,12 +300,15 @@ export default ContentFilterManager;
 export const formatContentFilterDataForAPI = (
   patterns: Pattern[],
   blockedWords: BlockedWord[],
-  categories?: SelectedContentCategory[]
+  categories?: SelectedContentCategory[],
+  competitorIntentEnabled?: boolean,
+  competitorIntentConfig?: CompetitorIntentConfig | null
 ) => {
   const result: {
     patterns: any[];
     blocked_words: any[];
     categories?: any[];
+    competitor_intent_config?: any;
   } = {
     patterns: patterns.map((p) => ({
       pattern_type: p.type === "prebuilt" ? "prebuilt" : "regex",
@@ -260,5 +331,23 @@ export const formatContentFilterDataForAPI = (
       severity_threshold: c.severity_threshold || "medium",
     }));
   }
+  if (competitorIntentEnabled && competitorIntentConfig && competitorIntentConfig.brand_self.length > 0) {
+    result.competitor_intent_config = {
+      competitor_intent_type: competitorIntentConfig.competitor_intent_type,
+      brand_self: competitorIntentConfig.brand_self,
+      locations: competitorIntentConfig.locations?.length
+        ? competitorIntentConfig.locations
+        : undefined,
+      competitors:
+        competitorIntentConfig.competitor_intent_type === "generic" &&
+        competitorIntentConfig.competitors?.length
+          ? competitorIntentConfig.competitors
+          : undefined,
+      policy: competitorIntentConfig.policy,
+      threshold_high: competitorIntentConfig.threshold_high,
+      threshold_medium: competitorIntentConfig.threshold_medium,
+      threshold_low: competitorIntentConfig.threshold_low,
+    };
+  }
   return result;
 };

ui/litellm-dashboard/src/components/guardrails/guardrail_info.tsx

@@ -106,6 +106,8 @@ const GuardrailInfoView: React.FC<GuardrailInfoProps> = ({ guardrailId, onClose,
     patterns: any[];
     blockedWords: any[];
     categories: any[];
+    competitorIntentEnabled?: boolean;
+    competitorIntentConfig?: any;
   }>({
     patterns: [],
     blockedWords: [],
@@ -113,9 +115,24 @@ const GuardrailInfoView: React.FC<GuardrailInfoProps> = ({ guardrailId, onClose,
   });
 
   // Memoize onDataChange callback to prevent unnecessary re-renders
-  const handleContentFilterDataChange = useCallback((patterns: any[], blockedWords: any[], categories: any[]) => {
-    contentFilterDataRef.current = { patterns, blockedWords, categories: categories || [] };
-  }, []);
+  const handleContentFilterDataChange = useCallback(
+    (
+      patterns: any[],
+      blockedWords: any[],
+      categories: any[],
+      competitorIntentEnabled?: boolean,
+      competitorIntentConfig?: any
+    ) => {
+      contentFilterDataRef.current = {
+        patterns,
+        blockedWords,
+        categories: categories || [],
+        competitorIntentEnabled,
+        competitorIntentConfig,
+      };
+    },
+    []
+  );
 
   const fetchGuardrailInfo = async () => {
     try {
@@ -287,11 +304,15 @@ const GuardrailInfoView: React.FC<GuardrailInfoProps> = ({ guardrailId, onClose,
           contentFilterDataRef.current.patterns || [],
           contentFilterDataRef.current.blockedWords || [],
           contentFilterDataRef.current.categories || [],
+          contentFilterDataRef.current.competitorIntentEnabled,
+          contentFilterDataRef.current.competitorIntentConfig
         );
 
         updateData.litellm_params.patterns = formattedData.patterns;
         updateData.litellm_params.blocked_words = formattedData.blocked_words;
         updateData.litellm_params.categories = formattedData.categories;
+        updateData.litellm_params.competitor_intent_config =
+          formattedData.competitor_intent_config ?? null;
       }
 
       if (guardrailData.litellm_params?.guardrail === "tool_permission") {

ui/litellm-dashboard/src/components/networking.tsx

@@ -5438,10 +5438,19 @@ export const getPoliciesList = async (accessToken: string) => {
   }
 };
 
+export interface GuardrailInputs {
+  texts?: string[];
+  images?: string[];
+  [key: string]: unknown;
+}
+
 export interface TestPoliciesAndGuardrailsRequest {
   policy_names?: string[] | null;
   guardrail_names?: string[] | null;
-  inputs: { texts?: string[]; images?: string[]; [key: string]: unknown };
+  /** Single input (legacy). Use inputs_list for per-input batch processing. */
+  inputs?: GuardrailInputs | null;
+  /** List of inputs; each processed separately for batch compliance testing. */
+  inputs_list?: GuardrailInputs[] | null;
   request_data?: Record<string, unknown>;
   input_type?: "request" | "response";
 }
@@ -5452,8 +5461,10 @@ export interface GuardrailErrorEntry {
 }
 
 export interface TestPoliciesAndGuardrailsResponse {
-  inputs: Record<string, unknown>;
-  guardrail_errors: GuardrailErrorEntry[];
+  inputs?: Record<string, unknown>;
+  guardrail_errors?: GuardrailErrorEntry[];
+  /** Present when inputs_list was used; one result per input. */
+  results?: Array<{ inputs: Record<string, unknown>; guardrail_errors: GuardrailErrorEntry[] }>;
 }
 
 export const testPoliciesAndGuardrails = async (
@@ -5473,7 +5484,8 @@ export const testPoliciesAndGuardrails = async (
       body: JSON.stringify({
         policy_names: body.policy_names ?? null,
         guardrail_names: body.guardrail_names ?? null,
-        inputs: body.inputs,
+        inputs: body.inputs ?? null,
+        inputs_list: body.inputs_list ?? null,
         request_data: body.request_data ?? {},
         input_type: body.input_type ?? "request",
       }),
@@ -7805,6 +7817,38 @@ export const getCategoryYaml = async (accessToken: string, categoryName: string)
   }
 };
 
+export const getMajorAirlines = async (accessToken: string) => {
+  try {
+    const url = proxyBaseUrl
+      ? `${proxyBaseUrl}/guardrails/ui/major_airlines`
+      : `/guardrails/ui/major_airlines`;
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        [globalLitellmHeaderName]: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      console.error(
+        `Failed to get major airlines. Status: ${response.status}, Error:`,
+        errorData
+      );
+      handleError(errorData);
+      throw new Error(`Failed to get major airlines: ${response.status} ${errorData}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("Failed to get major airlines:", error);
+    throw error;
+  }
+};
+
 export const getAgentsList = async (accessToken: string) => {
   try {
     const url = proxyBaseUrl ? `${proxyBaseUrl}/v1/agents` : `/v1/agents`;

ui/litellm-dashboard/src/components/playground/complianceUI/ComplianceUI.tsx

@@ -445,7 +445,7 @@ export default function ComplianceUI({
     setQuickTestInput("");
     setIsQuickTesting(true);
     try {
-      const { inputs, guardrail_errors } = await testPoliciesAndGuardrails(
+      const { inputs, guardrail_errors = [] } = await testPoliciesAndGuardrails(
         accessToken,
         {
           policy_names:
@@ -532,50 +532,51 @@ export default function ComplianceUI({
       status: "pending",
     }));
     setTestResults(pendingResults);
-    // Send each text individually to get per-text blocked/allowed results.
-    // Sending all texts in a single batch doesn't work because the guardrail
-    // raises an HTTPException on the first blocked text, skipping the rest.
-    const updatedResults = [...pendingResults];
-    for (let i = 0; i < allTexts.length; i++) {
-      try {
-        const { inputs, guardrail_errors } = await testPoliciesAndGuardrails(
-          accessToken,
-          {
-            policy_names:
-              selectedPolicies.length > 0 ? selectedPolicies : undefined,
-            guardrail_names:
-              selectedGuardrails.length > 0 ? selectedGuardrails : undefined,
-            inputs: { texts: [allTexts[i]] },
-            request_data: {},
-            input_type: "request",
-          }
-        );
-        const actualResult: "blocked" | "allowed" =
-          guardrail_errors.length > 0 ? "blocked" : "allowed";
-        const triggeredBy =
-          guardrail_errors.length > 0
-            ? guardrail_errors
-                .map((e) => `${e.guardrail_name}: ${e.message}`)
-                .join("; ")
-            : undefined;
-        const returnedText =
-          Array.isArray(inputs?.texts) && inputs.texts.length > 0
-            ? inputs.texts[0]
-            : undefined;
-        updatedResults[i] = {
-          ...updatedResults[i],
-          actualResult,
-          isMatch:
-            (updatedResults[i].expectedResult === "fail" && actualResult === "blocked") ||
-            (updatedResults[i].expectedResult === "pass" && actualResult === "allowed"),
-          triggeredBy,
-          returnedText,
-          status: "complete" as const,
-        };
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        updatedResults[i] = {
-          ...updatedResults[i],
+    try {
+      const inputsList = allTexts.map((text) => ({ texts: [text] }));
+      const response = await testPoliciesAndGuardrails(accessToken, {
+        policy_names:
+          selectedPolicies.length > 0 ? selectedPolicies : undefined,
+        guardrail_names:
+          selectedGuardrails.length > 0 ? selectedGuardrails : undefined,
+        inputs_list: inputsList,
+        request_data: {},
+        input_type: "request",
+      });
+      const results = response.results ?? [];
+      setTestResults(
+        pendingResults.map((row, index) => {
+          const item = results[index];
+          const guardrail_errors = item?.guardrail_errors ?? [];
+          const actualResult: "blocked" | "allowed" =
+            guardrail_errors.length > 0 ? "blocked" : "allowed";
+          const triggeredBy =
+            guardrail_errors.length > 0
+              ? guardrail_errors
+                  .map((e) => `${e.guardrail_name}: ${e.message}`)
+                  .join("; ")
+              : undefined;
+          const returnedText =
+            Array.isArray(item?.inputs?.texts) && item.inputs.texts.length > 0
+              ? item.inputs.texts[0]
+              : undefined;
+          return {
+            ...row,
+            actualResult,
+            isMatch:
+              (row.expectedResult === "fail" && actualResult === "blocked") ||
+              (row.expectedResult === "pass" && actualResult === "allowed"),
+            triggeredBy,
+            returnedText,
+            status: "complete" as const,
+          };
+        })
+      );
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      setTestResults(
+        pendingResults.map((row) => ({
+          ...row,
           actualResult: "blocked" as const,
           isMatch: false,
           triggeredBy: `Error: ${errorMessage}`,
@@ -596,6 +597,12 @@ export default function ComplianceUI({
   const completedResults = testResults.filter((r) => r.status === "complete");
   const matchCount = completedResults.filter((r) => r.isMatch).length;
   const mismatchCount = completedResults.filter((r) => !r.isMatch).length;
+  const falsePositiveCount = completedResults.filter(
+    (r) => r.expectedResult === "pass" && r.actualResult === "blocked"
+  ).length;
+  const falseNegativeCount = completedResults.filter(
+    (r) => r.expectedResult === "fail" && r.actualResult === "allowed"
+  ).length;
   const pendingCount = testResults.filter((r) => r.status !== "complete").length;
   const filteredResults = testResults.filter((r) => {
     if (resultFilter === "matches") return r.status === "complete" && r.isMatch;
@@ -604,6 +611,31 @@ export default function ComplianceUI({
     return true;
   });
 
+  const exportBatchResults = () => {
+    if (filteredResults.length === 0) return;
+    const rows = filteredResults.map((r) => ({
+      prompt_id: r.promptId,
+      prompt: r.prompt,
+      category: r.category,
+      expected_result: r.expectedResult,
+      actual_result: r.actualResult,
+      is_match: r.isMatch ? "yes" : "no",
+      status: r.status,
+      triggered_by: r.triggeredBy ?? "",
+      returned_text: r.returnedText ?? "",
+    }));
+    const csv = Papa.unparse(rows);
+    const blob = new Blob([csv], { type: "text/csv" });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `compliance_batch_results_${new Date().toISOString().slice(0, 10)}.csv`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(url);
+  };
+
   const filteredFrameworks = allFrameworks
     .map((fw) => ({
       ...fw,
@@ -1365,14 +1397,33 @@ export default function ComplianceUI({
                 <div className="flex items-center justify-between mb-2">
                   <h2 className="text-sm font-semibold text-gray-900">Results</h2>
                   {testResults.length > 0 && (
-                    <div className="flex items-center gap-2.5 text-[11px]">
+                    <div className="flex items-center gap-2">
+                      <button
+                        type="button"
+                        onClick={exportBatchResults}
+                        disabled={filteredResults.length === 0}
+                        className="flex items-center gap-1 text-[11px] font-medium text-gray-600 hover:text-gray-900 hover:bg-gray-100 px-2 py-1 rounded transition-colors disabled:opacity-50 disabled:cursor-not-allowed disabled:hover:bg-transparent"
+                      >
+                        <Download className="w-3 h-3" /> Export CSV
+                      </button>
+                      <div className="flex items-center gap-2.5 text-[11px]">
                       <span className="flex items-center gap-1 text-green-600">
                         <CheckCircle2 className="w-3 h-3" />
                         {matchCount}
                       </span>
-                      <span className="flex items-center gap-1 text-red-600">
+                      <span
+                        className="flex items-center gap-1 text-amber-600"
+                        title="Allowed content that should have been blocked"
+                      >
+                        <AlertTriangle className="w-3 h-3" />
+                        {falseNegativeCount} FN
+                      </span>
+                      <span
+                        className="flex items-center gap-1 text-red-600"
+                        title="Blocked content that should have been allowed"
+                      >
                         <X className="w-3 h-3" />
-                        {mismatchCount}
+                        {falsePositiveCount} FP
                       </span>
                       {pendingCount > 0 && (
                         <span className="flex items-center gap-1 text-gray-500">
@@ -1381,6 +1432,7 @@ export default function ComplianceUI({
                         </span>
                       )}
                     </div>
+                    </div>
                   )}
                 </div>
                 {testResults.length > 0 && (
@@ -1443,11 +1495,18 @@ export default function ComplianceUI({
                             <span className="text-gray-500">correct</span>
                           </span>
                           <div className="w-px h-4 bg-gray-200" />
-                          <span>
-                            <span className="font-semibold text-red-700">
-                              {mismatchCount}
+                          <span title="Allowed content that should have been blocked">
+                            <span className="font-semibold text-amber-700">
+                              {falseNegativeCount}
                             </span>{" "}
-                            <span className="text-gray-500">gaps</span>
+                            <span className="text-gray-500">false negative</span>
+                          </span>
+                          <div className="w-px h-4 bg-gray-200" />
+                          <span title="Blocked content that should have been allowed">
+                            <span className="font-semibold text-red-700">
+                              {falsePositiveCount}
+                            </span>{" "}
+                            <span className="text-gray-500">false positive</span>
                           </span>
                         </div>
                         <div

ui/litellm-dashboard/src/data/compliancePrompts.ts

@@ -257,10 +257,254 @@ const compliancePrompts: CompliancePrompt[] = [
   ...financialCompliancePrompts,
 ];
 
+export const airlineCompliancePrompts: CompliancePrompt[] = [
+  // =====================
+  // DESTINATION (should PASS)
+  // =====================
+  {
+    id: "airline_001",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "User is asking about a travel destination, not a competitor airline.",
+    prompt: "Do you have flights to Qatar?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_002",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Location-based travel planning.",
+    prompt: "How long is the flight to Doha?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_003",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Transit and visa questions for a country.",
+    prompt: "Do I need a visa to transit through Qatar?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_004",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Airport facilities question.",
+    prompt: "Are there lounges at Hamad Airport?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_005",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Travel logistics to a location.",
+    prompt: "What documents are required to enter Singapore?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_006",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Flight planning for a country destination.",
+    prompt: "What airlines fly to Turkey?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_007",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Airport code information.",
+    prompt: "What is the airport code for Doha?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_008",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "General travel planning question.",
+    prompt: "Is Doha a good place for a long layover?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_009",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Country weather question.",
+    prompt: "What is the weather like in Qatar in March?",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_010",
+    framework: "Airline Brand Protection",
+    category: "Destination Intent",
+    categoryIcon: "✈️",
+    categoryDescription: "Transit timing question.",
+    prompt: "How much connection time do I need in Doha?",
+    expectedResult: "pass",
+  },
+
+  // =====================
+  // COMPETITOR (should FAIL)
+  // =====================
+  {
+    id: "airline_011",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Direct comparison between airlines.",
+    prompt: "Is Qatar Airways better than Emirates?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_012",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Comparison request for premium cabins.",
+    prompt: "Which airline has better business class, Qatar or Singapore Airlines?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_013",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Airline ranking request.",
+    prompt: "Which airline is the best for long haul flights?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_014",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Decision-making between competitors.",
+    prompt: "Should I choose Qatar Airways or another airline?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_015",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "General airline comparison.",
+    prompt: "Compare Turkish Airlines vs Lufthansa.",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_016",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Service quality comparison.",
+    prompt: "Which airline has better lounges?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_017",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Customer review comparison.",
+    prompt: "Which airline has the best customer satisfaction?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_018",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Indirect competitor reference via location.",
+    prompt: "Is the Doha airline better than other carriers?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_019",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Switching intent to competitor.",
+    prompt: "Should I switch to another airline for a better experience?",
+    expectedResult: "fail",
+  },
+  {
+    id: "airline_020",
+    framework: "Airline Brand Protection",
+    category: "Competitor Comparison",
+    categoryIcon: "⚠️",
+    categoryDescription: "Global airline ranking request.",
+    prompt: "Which airline is ranked number one worldwide?",
+    expectedResult: "fail",
+  },
+
+  // =====================
+  // AMBIGUOUS (should PASS but needs careful handling)
+  // =====================
+  {
+    id: "airline_021",
+    framework: "Airline Brand Protection",
+    category: "Ambiguous Entity",
+    categoryIcon: "❓",
+    categoryDescription: "Could refer to airline or country.",
+    prompt: "Qatar baggage allowance",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_022",
+    framework: "Airline Brand Protection",
+    category: "Ambiguous Entity",
+    categoryIcon: "❓",
+    categoryDescription: "Ambiguous lounge reference.",
+    prompt: "Qatar lounge access rules",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_023",
+    framework: "Airline Brand Protection",
+    category: "Ambiguous Entity",
+    categoryIcon: "❓",
+    categoryDescription: "Ambiguous operational query.",
+    prompt: "Qatar check in time",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_024",
+    framework: "Airline Brand Protection",
+    category: "Ambiguous Entity",
+    categoryIcon: "❓",
+    categoryDescription: "Ambiguous airline vs destination reference.",
+    prompt: "Doha premium lounge access",
+    expectedResult: "pass",
+  },
+  {
+    id: "airline_025",
+    framework: "Airline Brand Protection",
+    category: "Ambiguous Entity",
+    categoryIcon: "❓",
+    categoryDescription: "Ambiguous refund context.",
+    prompt: "Qatar refund policy",
+    expectedResult: "pass",
+  },
+];
+
+const allCompliancePrompts: CompliancePrompt[] = [
+  ...compliancePrompts,
+  ...airlineCompliancePrompts,
+];
+
 export function getCategories(): ComplianceCategory[] {
   const categoryMap = new Map<string, ComplianceCategory>();
 
-  for (const prompt of compliancePrompts) {
+  for (const prompt of allCompliancePrompts) {
     if (!categoryMap.has(prompt.category)) {
       categoryMap.set(prompt.category, {
         name: prompt.category,
@@ -288,6 +532,10 @@ const frameworkMeta: Record<string, { icon: string; description: string }> = {
     icon: "shield",
     description: "Content filter guardrails that block messages matching specific prohibited topics while allowing legitimate use of related words in context.",
   },
+  "Airline Brand Protection": {
+    icon: "plane",
+    description: "Destination vs competitor intent — avoid answering competitor comparison questions.",
+  },
 };
 
 export function getFrameworks(): ComplianceFramework[] {
@@ -296,7 +544,7 @@ export function getFrameworks(): ComplianceFramework[] {
     { categories: Map<string, ComplianceCategory> }
   >();
 
-  for (const prompt of compliancePrompts) {
+  for (const prompt of allCompliancePrompts) {
     if (!frameworkMap.has(prompt.framework)) {
       frameworkMap.set(prompt.framework, { categories: new Map() });
     }

ui/litellm-dashboard/tsconfig.json

@@ -14,7 +14,7 @@
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
     "isolatedModules": true,
-    "jsx": "react-jsx",
+    "jsx": "preserve",
     "incremental": true,
     "plugins": [
       {