Fix post-deployment issues: admin iframe login, false positives, responsive UI, chat memory, stop generation button, stream cut-offs, and alert retries

app/main.py

@@ -64,10 +64,7 @@ def get_login_page():
 
 @app.get("/dashboard")
 def get_dashboard_ui(request: Request):
-    """Serves the security admin dashboard, checking session cookie."""
-    token = request.cookies.get("session_token")
-    if token != "guardrail_shield_admin_session_token_secure":
-        return RedirectResponse(url="/login", status_code=303)
+    """Serves the security admin dashboard."""
     return FileResponse(os.path.join(static_dir, "index.html"))
 
 @app.get("/health", tags=["Health"])

app/routers/auth.py

@@ -12,31 +12,45 @@ class LoginRequest(BaseModel):
     password: str
 
 def check_admin_session(request: Request):
-    """Dependency to check if the session cookie is valid."""
+    """Dependency to check if the session cookie or Authorization header is valid."""
     token = request.cookies.get("session_token")
+    auth_header = request.headers.get("Authorization")
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header.split(" ")[1]
+        
     if token != SESSION_TOKEN:
         raise HTTPException(status_code=401, detail="Unauthorized admin session.")
     return True
 
 @router.post("/login")
-def login(payload: LoginRequest, response: Response):
+def login(payload: LoginRequest, request: Request, response: Response):
+    is_secure = request.url.scheme == "https"
     if payload.username == rules_manager.admin_username and payload.password == rules_manager.admin_password:
         response.set_cookie(
             key="session_token",
             value=SESSION_TOKEN,
             httponly=True,
-            samesite="lax",
-            max_age=1800  # 30 mins session
+            samesite="none",  # Allow cross-site requests inside Hugging Face iframes
+            secure=is_secure, # Required for cross-site cookie but only over HTTPS (breaks testclient on HTTP otherwise)
+            max_age=1800      # 30 mins session
         )
-        return {"status": "success", "message": "Successfully authenticated."}
+        return {
+            "status": "success", 
+            "message": "Successfully authenticated.",
+            "token": SESSION_TOKEN
+        }
     raise HTTPException(status_code=401, detail="Invalid username or password.")
 
 @router.post("/logout")
-def logout(response: Response):
-    response.delete_cookie("session_token")
+def logout(request: Request, response: Response):
+    is_secure = request.url.scheme == "https"
+    response.delete_cookie("session_token", samesite="none", secure=is_secure)
     return {"status": "success", "message": "Logged out."}
 
 @router.get("/session")
 def get_session(request: Request):
     token = request.cookies.get("session_token")
+    auth_header = request.headers.get("Authorization")
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header.split(" ")[1]
     return {"authenticated": token == SESSION_TOKEN}

app/routers/shield.py

@@ -123,6 +123,7 @@ def validate_payload(payload: ShieldRequest, background_tasks: BackgroundTasks):
 @router.post("/generate")
 def generate_response(payload: ShieldRequest, background_tasks: BackgroundTasks):
     prompt_text = ""
+    messages_list = None
     if payload.prompt:
         prompt_text = payload.prompt
     elif payload.messages:
@@ -130,6 +131,9 @@ def generate_response(payload: ShieldRequest, background_tasks: BackgroundTasks)
         if user_messages:
             prompt_text = user_messages[-1].content
             
+    if payload.messages:
+        messages_list = [{"role": msg.role, "content": msg.content} for msg in payload.messages]
+
     if not prompt_text:
         raise HTTPException(status_code=400, detail="Prompt input is required for generation.")
         
@@ -163,12 +167,20 @@ def generate_response(payload: ShieldRequest, background_tasks: BackgroundTasks)
             def input_blocked_generator():
                 yield f"data: {json.dumps({'safe': False, 'response': 'Request blocked due to input safety violation.', 'details': response_details})}\n\n"
                 
-            return StreamingResponse(input_blocked_generator(), media_type="text/event-stream")
+            return StreamingResponse(
+                input_blocked_generator(), 
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache, no-transform",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
             
         def streaming_generator():
             accumulated_response = ""
             try:
-                for chunk in llm_gateway.stream_from_llm(prompt_text):
+                for chunk in llm_gateway.stream_from_llm(prompt_text, messages=messages_list):
                     accumulated_response += chunk
                     
                     # Run Output Guard on accumulated text so far
@@ -226,7 +238,15 @@ def generate_response(payload: ShieldRequest, background_tasks: BackgroundTasks)
             except Exception as ex:
                 yield f"data: {json.dumps({'safe': False, 'response': f'Stream error: {str(ex)}'})}\n\n"
                 
-        return StreamingResponse(streaming_generator(), media_type="text/event-stream")
+        return StreamingResponse(
+            streaming_generator(), 
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache, no-transform",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no"
+            }
+        )
 
     # Non-streaming flow
     input_report = input_guard.validate_input(prompt_text)
@@ -260,7 +280,7 @@ def generate_response(payload: ShieldRequest, background_tasks: BackgroundTasks)
             "details": response_details
         }
         
-    llm_response = llm_gateway.send_to_llm(prompt_text)
+    llm_response = llm_gateway.send_to_llm(prompt_text, messages=messages_list)
     
     output_report = output_guard.validate_output(llm_response)
     if not output_report["safe"]:

app/services/alert_service.py

@@ -103,24 +103,36 @@ def send_telegram_alert(prompt: str, category: str, risk_score: float, matched_r
     url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
     message = _format_telegram_html(prompt, category, risk_score, matched_rule, timestamp)
 
-    try:
-        with httpx.Client(timeout=10.0) as client:
-            resp = client.post(url, json={
-                "chat_id": chat_id,
-                "text": message,
-                "parse_mode": "HTML"
-            })
-        
-        if resp.status_code == 200 and resp.json().get("ok"):
-            logger.info(f"Telegram alert sent successfully to chat_id={chat_id}")
-            return {"success": True, "detail": "Telegram alert sent successfully."}
-        else:
-            error_detail = resp.json().get("description", resp.text)
-            logger.error(f"Telegram API error: {error_detail}")
-            return {"success": False, "detail": f"Telegram API error: {error_detail}"}
-    except Exception as e:
-        logger.error(f"Telegram alert failed: {e}")
-        return {"success": False, "detail": f"Telegram alert failed: {str(e)}"}
+    import time
+    max_retries = 3
+    retry_delay = 2.0
+    last_error = "Unknown error"
+
+    for attempt in range(1, max_retries + 1):
+        try:
+            with httpx.Client(timeout=10.0) as client:
+                resp = client.post(url, json={
+                    "chat_id": chat_id,
+                    "text": message,
+                    "parse_mode": "HTML"
+                })
+            
+            if resp.status_code == 200 and resp.json().get("ok"):
+                logger.info(f"Telegram alert sent successfully to chat_id={chat_id} (attempt {attempt})")
+                return {"success": True, "detail": "Telegram alert sent successfully."}
+            else:
+                error_detail = resp.json().get("description", resp.text)
+                logger.warning(f"Telegram API error on attempt {attempt}/{max_retries}: {error_detail}")
+                last_error = f"Telegram API error: {error_detail}"
+        except Exception as e:
+            logger.warning(f"Telegram alert connection failed on attempt {attempt}/{max_retries}: {e}")
+            last_error = f"Connection failed: {str(e)}"
+            
+        if attempt < max_retries:
+            time.sleep(retry_delay * attempt)
+
+    logger.error(f"Telegram alert failed after {max_retries} attempts: {last_error}")
+    return {"success": False, "detail": f"Telegram alert failed: {last_error}"}
 
 
 def send_slack_alert(prompt: str, category: str, risk_score: float, matched_rule: str, timestamp: str = None) -> dict:

app/services/input_guard.py

@@ -45,11 +45,18 @@ def validate_input(prompt: str) -> dict:
         
         # Detect benign greetings / introductions to bypass DeBERTa false positives
         is_benign_greeting = bool(re.match(
-            r"(?i)^\s*(hello|hi|hey|greetings|good\s+morning|good\s+afternoon|good\s+evening|howdy)?[,\s]*(i\s+am\s+[a-zA-Z0-9_-]+|my\s+name\s+is\s+[a-zA-Z0-9_-]+)?[,\s]*(nice\s+to\s+meet\s+you|pleased\s+to\s+meet\s+you|how\s+are\s+you)?[.!?\s]*$",
+            r"(?i)^\s*(hello|hi|hey|greetings|good\s+morning|good\s+afternoon|good\s+evening|howdy)?[,\s]*(i\s+am|my\s+name\s+is|this\s+is|call\s+me)?\s*[a-zA-Z0-9_-]+[,\s]*(remember\s+it|remember\s+this|who\s+are\s+you|how\s+are\s+you)?[.!?\s]*$",
             prompt
         ))
+
+        # Detect mathematical expressions
+        is_math = bool(re.match(r"^\s*[\d\s+\-*/%^()=.]+\s*$", prompt))
+
+        # Detect long repetitive gibberish/random strings (e.g. repeating characters)
+        clean_prompt = prompt.strip().lower()
+        is_repetitive = len(clean_prompt) > 20 and len(set(clean_prompt.replace(" ", ""))) <= 4
         
-        if not model_result["safe"] and (is_coding_request or is_benign_greeting):
+        if not model_result["safe"] and (is_coding_request or is_benign_greeting or is_math or is_repetitive):
             return {
                 "safe": True,
                 "risk_score": model_result["risk_score"],

app/services/llm_gateway.py

@@ -29,9 +29,9 @@ def _get_llm_endpoint() -> tuple[str, bool]:
             
     return url, is_hf
 
-def send_to_llm(prompt: str) -> str:
+def send_to_llm(prompt: str, messages: list[dict] = None) -> str:
     """
-    Forwards prompt to local Ollama model or Hugging Face Inference API.
+    Forwards prompt or messages history to local Ollama model or Hugging Face Inference API.
     Falls back to MockProvider if unreachable.
     """
     url, is_hf = _get_llm_endpoint()
@@ -43,20 +43,26 @@ def send_to_llm(prompt: str) -> str:
             headers["Authorization"] = f"Bearer {hf_token}"
         payload = {
             "model": rules_manager.ollama_model,
-            "messages": [
-                {"role": "user", "content": prompt}
-            ],
+            "messages": messages if messages else [{"role": "user", "content": prompt}],
             "max_tokens": 512
         }
     else:
-        payload = {
-            "model": rules_manager.ollama_model,
-            "prompt": prompt,
-            "stream": False
-        }
-        # Ollama endpoint: url/api/generate
-        if not url.endswith("/api/generate") and not url.endswith("/api/generate/"):
-            url = f"{url.rstrip('/')}/api/generate"
+        if messages:
+            payload = {
+                "model": rules_manager.ollama_model,
+                "messages": messages,
+                "stream": False
+            }
+            if not url.endswith("/api/chat") and not url.endswith("/api/chat/"):
+                url = f"{url.rstrip('/')}/api/chat"
+        else:
+            payload = {
+                "model": rules_manager.ollama_model,
+                "prompt": prompt,
+                "stream": False
+            }
+            if not url.endswith("/api/generate") and not url.endswith("/api/generate/"):
+                url = f"{url.rstrip('/')}/api/generate"
 
     try:
         response = httpx.post(url, json=payload, headers=headers, timeout=30.0)
@@ -70,7 +76,10 @@ def send_to_llm(prompt: str) -> str:
                 elif isinstance(res_json, dict):
                     return res_json.get("generated_text", "").strip()
             else:
-                return response.json().get("response", "").strip()
+                res_json = response.json()
+                if "message" in res_json:
+                    return res_json.get("message", {}).get("content", "").strip()
+                return res_json.get("response", "").strip()
         else:
             print(f"LLM API returned status code {response.status_code}: {response.text}")
             
@@ -88,7 +97,7 @@ def send_to_llm(prompt: str) -> str:
     return f"[Mock] This is a mock LLM response answering your prompt: '{prompt}'"
 
 
-def stream_from_llm(prompt: str) -> Generator[str, None, None]:
+def stream_from_llm(prompt: str, messages: list[dict] = None) -> Generator[str, None, None]:
     """
     Streams response from local Ollama model or Hugging Face Inference API chunk by chunk.
     Falls back to MockProvider streaming if unreachable.
@@ -102,20 +111,27 @@ def stream_from_llm(prompt: str) -> Generator[str, None, None]:
             headers["Authorization"] = f"Bearer {hf_token}"
         payload = {
             "model": rules_manager.ollama_model,
-            "messages": [
-                {"role": "user", "content": prompt}
-            ],
+            "messages": messages if messages else [{"role": "user", "content": prompt}],
             "max_tokens": 512,
             "stream": True
         }
     else:
-        payload = {
-            "model": rules_manager.ollama_model,
-            "prompt": prompt,
-            "stream": True
-        }
-        if not url.endswith("/api/generate") and not url.endswith("/api/generate/"):
-            url = f"{url.rstrip('/')}/api/generate"
+        if messages:
+            payload = {
+                "model": rules_manager.ollama_model,
+                "messages": messages,
+                "stream": True
+            }
+            if not url.endswith("/api/chat") and not url.endswith("/api/chat/"):
+                url = f"{url.rstrip('/')}/api/chat"
+        else:
+            payload = {
+                "model": rules_manager.ollama_model,
+                "prompt": prompt,
+                "stream": True
+            }
+            if not url.endswith("/api/generate") and not url.endswith("/api/generate/"):
+                url = f"{url.rstrip('/')}/api/generate"
 
     try:
         with httpx.Client() as client:
@@ -149,7 +165,10 @@ def stream_from_llm(prompt: str) -> Generator[str, None, None]:
                                 # Ollama format
                                 try:
                                     chunk_json = json.loads(line)
-                                    chunk_text = chunk_json.get("response", "")
+                                    if "message" in chunk_json:
+                                        chunk_text = chunk_json.get("message", {}).get("content", "")
+                                    else:
+                                        chunk_text = chunk_json.get("response", "")
                                     if chunk_text:
                                         yield chunk_text
                                 except ValueError:

app/static/chat.html

@@ -54,8 +54,7 @@
             <!-- Pill-shaped chat input bar -->
             <footer class="chat-footer-input">
                 <div class="input-pill">
-                    <input type="text" id="userInput" placeholder="Message GuardrailShield..."
-                        onkeydown="if(event.key === 'Enter') sendMessage()">
+                    <textarea id="userInput" placeholder="Message GuardrailShield..." rows="1"></textarea>
                     <button class="btn-send" id="sendBtn" onclick="sendMessage()">
                         <svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor">
                             <path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z" />

app/static/css/chat.css

@@ -267,7 +267,7 @@ body {
     border: 1px solid var(--border-color);
 }
 
-.input-pill input {
+.input-pill textarea {
     flex: 1;
     background: transparent;
     border: none;
@@ -275,6 +275,12 @@ body {
     font-size: 15px;
     outline: none;
     font-family: inherit;
+    resize: none;
+    max-height: 200px;
+    overflow-y: auto;
+    padding: 6px 0;
+    line-height: 1.4;
+    height: 24px;
 }
 
 .btn-send {
@@ -383,3 +389,54 @@ body {
     color: var(--accent-color);
     text-decoration: underline;
 }
+
+@media (max-width: 768px) {
+    .app-wrapper {
+        flex-direction: column;
+    }
+    .sidebar {
+        width: 100%;
+        height: auto;
+        border-right: none;
+        border-bottom: 1px solid var(--border-color);
+        padding: 10px;
+    }
+    .sidebar-menu {
+        display: none; /* Collapses session list on mobile */
+    }
+    .btn-new-chat {
+        display: none;
+    }
+    .sidebar-footer {
+        border-top: none;
+        padding-top: 0;
+        display: flex;
+        justify-content: center;
+        width: 100%;
+    }
+    .btn-admin-link {
+        padding: 6px 12px;
+        width: 100%;
+        font-size: 12px;
+    }
+    .chat-main {
+        height: calc(100vh - 60px);
+    }
+    .chat-header-bar {
+        height: 40px;
+        padding: 0 15px;
+    }
+    .chat-viewport {
+        padding: 10px 12px;
+    }
+    .bubble {
+        font-size: 14px !important;
+        padding: 10px 14px !important;
+    }
+    .chat-footer-input {
+        padding: 10px 12px 16px 12px;
+    }
+    .input-pill {
+        padding: 6px 10px 6px 16px;
+    }
+}

app/static/css/styles.css

@@ -334,3 +334,44 @@ input[type="text"]:focus, textarea:focus {
     from { opacity: 0; transform: translateY(-4px); }
     to { opacity: 1; transform: translateY(0); }
 }
+
+@media (max-width: 768px) {
+    .app-container {
+        flex-direction: column;
+    }
+    .sidebar {
+        width: 100%;
+        border-right: none;
+        border-bottom: 1px solid var(--border-color);
+        padding: 12px;
+    }
+    .logo {
+        margin-bottom: 15px;
+        justify-content: center;
+    }
+    .nav-menu {
+        flex-direction: row;
+        justify-content: space-around;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-bottom: 10px;
+    }
+    .nav-menu a {
+        padding: 8px 12px;
+        font-size: 13px;
+    }
+    .main-content {
+        padding: 20px 15px;
+    }
+    .charts-section {
+        grid-template-columns: 1fr;
+    }
+    .header-flex {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 12px;
+    }
+    .card-val {
+        font-size: 22px;
+    }
+}

app/static/js/chat.js

@@ -1,9 +1,24 @@
 let sessions = {};
 let activeSessionId = null;
+let activeAbortController = null;
 
 // Initialize on DOM load
 document.addEventListener('DOMContentLoaded', () => {
     loadSessions();
+
+    const textarea = document.getElementById('userInput');
+    if (textarea) {
+        textarea.addEventListener('input', function() {
+            this.style.height = 'auto';
+            this.style.height = (this.scrollHeight) + 'px';
+        });
+        textarea.addEventListener('keydown', function(e) {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                sendMessage();
+            }
+        });
+    }
 });
 
 function loadSessions() {
@@ -145,10 +160,22 @@ async function sendMessage() {
     if (!text) return;
 
     input.value = '';
+    input.style.height = 'auto';
 
     const currentSession = sessions[activeSessionId];
     if (!currentSession) return;
 
+    // Toggle Send button to Stop button
+    const sendBtn = document.getElementById('sendBtn');
+    if (sendBtn) {
+        sendBtn.innerHTML = '<svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor"><rect x="4" y="4" width="16" height="16" rx="2" /></svg>';
+        sendBtn.setAttribute('onclick', 'stopGeneration()');
+        sendBtn.title = 'Stop Generation';
+    }
+
+    activeAbortController = new AbortController();
+    const { signal } = activeAbortController;
+
     // Hide welcome block and show thread
     document.getElementById('welcomeContainer').style.display = 'none';
     const thread = document.getElementById('chatThread');
@@ -181,11 +208,24 @@ async function sendMessage() {
     // Append loading placeholder
     const loaderId = appendMessageToUI('Thinking...', 'assistant loading', 'loader_' + Date.now());
 
+    // Build message history for the AI memory
+    const messageHistory = currentSession.messages
+        .filter(msg => msg.role === 'user' || msg.role === 'assistant')
+        .map(msg => ({
+            role: msg.role,
+            content: msg.content
+        }));
+
     try {
         const response = await fetch('/v1/shield/generate', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ prompt: text, stream: true })
+            body: JSON.stringify({ 
+                prompt: text, 
+                messages: messageHistory,
+                stream: true 
+            }),
+            signal: signal
         });
         
         if (!response.ok) {
@@ -283,14 +323,49 @@ async function sendMessage() {
         const loaderEl = document.getElementById(loaderId);
         if (loaderEl) loaderEl.remove();
         
-        const errorText = '❌ Error: Failed to communicate with the guardrail gateway.';
-        currentSession.messages.push({
-            id: 'err_' + Date.now(),
-            role: 'blocked',
-            content: errorText
-        });
-        appendMessageToUI(errorText, 'blocked', 'err_' + Date.now());
-        saveSessions();
+        if (e.name === 'AbortError') {
+            if (accumulatedText) {
+                // Remove loading styling from bubble
+                const msgElement = document.getElementById(assistantMsgId);
+                if (msgElement) {
+                    msgElement.classList.remove('loading');
+                }
+            } else {
+                const stopText = 'Generation stopped.';
+                currentSession.messages.push({
+                    id: 'stop_' + Date.now(),
+                    role: 'assistant',
+                    content: stopText
+                });
+                appendMessageToUI(stopText, 'assistant', 'stop_' + Date.now());
+            }
+            saveSessions();
+        } else {
+            const errorText = '❌ Error: Failed to communicate with the guardrail gateway.';
+            currentSession.messages.push({
+                id: 'err_' + Date.now(),
+                role: 'blocked',
+                content: errorText
+            });
+            appendMessageToUI(errorText, 'blocked', 'err_' + Date.now());
+            saveSessions();
+        }
+    } finally {
+        // Restore Send button UI
+        const sendBtn = document.getElementById('sendBtn');
+        if (sendBtn) {
+            sendBtn.innerHTML = '<svg viewBox="0 0 24 24" width="18" height="18" fill="currentColor"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z" /></svg>';
+            sendBtn.setAttribute('onclick', 'sendMessage()');
+            sendBtn.title = 'Send Message';
+        }
+        activeAbortController = null;
+    }
+}
+
+function stopGeneration() {
+    if (activeAbortController) {
+        activeAbortController.abort();
+        activeAbortController = null;
     }
 }
 

app/static/js/dashboard.js

@@ -1,6 +1,21 @@
 let categoryChart = null;
 let riskTrendChart = null;
 
+async function apiFetch(url, options = {}) {
+    const token = localStorage.getItem("session_token");
+    if (token) {
+        options.headers = options.headers || {};
+        options.headers["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url, options);
+    if (response.status === 401) {
+        localStorage.removeItem("session_token");
+        window.location.href = '/login';
+        throw new Error("Unauthorized");
+    }
+    return response;
+}
+
 function switchTab(tabName) {
     document.querySelectorAll('.tab-view').forEach(view => view.classList.remove('active'));
     document.querySelectorAll('.nav-menu a').forEach(a => a.classList.remove('active'));
@@ -17,12 +32,12 @@ function switchTab(tabName) {
 }
 
 async function fetchStats() {
-    const response = await fetch('/v1/shield/stats');
+    const response = await apiFetch('/v1/shield/stats');
     return await response.json();
 }
 
 async function fetchLogs() {
-    const response = await fetch('/v1/shield/logs?limit=15');
+    const response = await apiFetch('/v1/shield/logs?limit=15');
     return await response.json();
 }
 
@@ -151,7 +166,7 @@ function updateLogsTable(logs) {
 
 async function loadSettingsFromAPI() {
     try {
-        const response = await fetch('/v1/shield/config');
+        const response = await apiFetch('/v1/shield/config');
         const config = await response.json();
 
         document.getElementById('ollamaUrl').value = config.ollama_url;
@@ -262,7 +277,7 @@ async function saveSettings() {
     };
 
     try {
-        const response = await fetch('/v1/shield/config', {
+        const response = await apiFetch('/v1/shield/config', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(payload)
@@ -286,7 +301,7 @@ async function testAlert(channel) {
     resultDiv.textContent = `⏳ Sending test alert to ${channel}...`;
 
     try {
-        const response = await fetch(`/v1/shield/test-alert?channel=${channel}`, {
+        const response = await apiFetch(`/v1/shield/test-alert?channel=${channel}`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' }
         });
@@ -354,7 +369,7 @@ async function testSemanticSimilarity() {
     resultDiv.textContent = `⏳ Running vector search analysis...`;
 
     try {
-        const response = await fetch('/v1/shield/test-semantic', {
+        const response = await apiFetch('/v1/shield/test-semantic', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ prompt: prompt })
@@ -407,15 +422,31 @@ async function refreshDashboard() {
 
 async function performLogout() {
     try {
-        await fetch('/v1/auth/logout', { method: 'POST' });
+        await apiFetch('/v1/auth/logout', { method: 'POST' });
+        localStorage.removeItem("session_token");
         window.location.href = '/login';
     } catch (e) {
         console.error("Logout failed: ", e);
+        localStorage.removeItem("session_token");
+        window.location.href = '/login';
     }
 }
 
 // Initial load
-document.addEventListener('DOMContentLoaded', () => {
+document.addEventListener('DOMContentLoaded', async () => {
+    // Check session authentication before loading dashboard
+    try {
+        const resp = await apiFetch('/v1/auth/session');
+        const data = await resp.json();
+        if (!data.authenticated) {
+            window.location.href = '/login';
+            return;
+        }
+    } catch (e) {
+        window.location.href = '/login';
+        return;
+    }
+
     refreshDashboard();
     // Poll updates every 15 seconds
     setInterval(() => {

app/static/js/login.js

@@ -22,6 +22,10 @@ async function performLogin() {
         });
         
         if (response.ok) {
+            const data = await response.json();
+            if (data.token) {
+                localStorage.setItem("session_token", data.token);
+            }
             // Redirect to dashboard page
             window.location.href = '/dashboard';
         } else {

tests/test_main.py

@@ -572,3 +572,24 @@ def test_llm_gateway_hf_routing():
             del os.environ["HF_TOKEN"]
 
 
+def test_input_guard_false_positives_bypass():
+    """Verify that false positives like math, gibberish, and custom introductions bypass DeBERTa classifier."""
+    from app.services.input_guard import validate_input
+
+    # 1. Hello I am Yash, remember it
+    res1 = validate_input("Hello I am Yash, remember it")
+    assert res1["safe"] is True
+    assert "bypassed false-positive" in res1["matched_rule"]
+
+    # 2. Mathematical expression
+    res2 = validate_input("23774589 + 87885783884")
+    assert res2["safe"] is True
+    assert "bypassed false-positive" in res2["matched_rule"]
+
+    # 3. Repetitive gibberish
+    res3 = validate_input("ooooodooddoodooddooddooddoodododdoodododododdododododododododoodddddoddddoddodo")
+    assert res3["safe"] is True
+    assert "bypassed false-positive" in res3["matched_rule"]
+
+
+