Add Microsoft Copilot provider with CAPTCHA support

- Created providers/copilot_provider.py with CAPTCHA detection
- Created copilot_session.py for persistent cookies (30 days, unlimited conversations)
- Updated admin_router.py with CAPTCHA endpoints:
* /qaz/copilot/captcha/status - Check if CAPTCHA pending
* /qaz/copilot/captcha/screenshot - Get CAPTCHA screenshot
* /qaz/copilot/captcha/solved - Mark as solved
* /qaz/copilot/captcha/clear - Clear state
* /qaz/copilot/session/status - Check session status
- Updated engine.py to include Copilot provider
- Updated config.py with copilot-gpt-4 model
- Updated static/qaz.html (admin dashboard /qazmlp) with:
* CAPTCHA solving UI with screenshot display
* Session status checker
* Auto-refresh every 10 seconds

Features:
- Detects CAPTCHA challenges automatically
- Saves cookies for 30 days (unlimited conversations)
- Starts new chat for each request (no context sharing)
- Admin dashboard shows CAPTCHA screenshot for solving
- No conversation limit

admin_router.py

@@ -3,6 +3,7 @@ from pydantic import BaseModel
 from typing import List, Optional
 import secrets
 import uuid
+import asyncio
 
 from db import get_supabase
 
@@ -131,3 +132,111 @@ async def lookup_key_by_token(req: LookupKeyRequest):
         elif hasattr(e, 'args') and len(e.args) > 0:
             error_msg = str(e.args[0])
         raise HTTPException(status_code=500, detail=error_msg)
+
+# --- Copilot CAPTCHA Handling ---
+
+@router.get("/copilot/captcha/status")
+async def copilot_captcha_status():
+    """Check if Copilot has a pending CAPTCHA challenge."""
+    try:
+        from providers.copilot_provider import CopilotProvider
+        
+        is_pending = CopilotProvider.is_captcha_pending()
+        
+        if is_pending:
+            # Check if screenshot exists
+            import os
+            screenshot_path = "/tmp/copilot_captcha.png"
+            has_screenshot = os.path.exists(screenshot_path)
+            
+            return {
+                "captcha_required": True,
+                "has_screenshot": has_screenshot,
+                "screenshot_url": "/qaz/copilot/captcha/screenshot" if has_screenshot else None,
+                "message": "CAPTCHA verification required. Please solve it in the admin panel."
+            }
+        else:
+            return {
+                "captcha_required": False,
+                "message": "No CAPTCHA pending"
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/copilot/captcha/screenshot")
+async def copilot_captcha_screenshot():
+    """Get the CAPTCHA screenshot for solving."""
+    import os
+    from fastapi.responses import FileResponse
+    
+    screenshot_path = "/tmp/copilot_captcha.png"
+    
+    if not os.path.exists(screenshot_path):
+        raise HTTPException(status_code=404, detail="No CAPTCHA screenshot available")
+    
+    return FileResponse(screenshot_path, media_type="image/png")
+
+@router.post("/copilot/captcha/solved")
+async def copilot_captcha_solved():
+    """Mark CAPTCHA as solved and save session."""
+    try:
+        from providers.copilot_provider import CopilotProvider
+        from copilot_session import CopilotSessionManager
+        
+        # Get the context with CAPTCHA
+        context = CopilotProvider.get_captcha_context()
+        
+        if not context:
+            raise HTTPException(status_code=400, detail="No CAPTCHA context found")
+        
+        # Wait a bit for user to solve
+        await asyncio.sleep(2)
+        
+        # Save cookies from the solved session
+        cookies = await context.cookies()
+        session_mgr = CopilotSessionManager()
+        session_mgr.save_cookies(cookies)
+        
+        # Clear the pending state
+        CopilotProvider.clear_captcha_pending()
+        
+        # Close the context
+        await context.close()
+        
+        return {
+            "status": "success",
+            "message": "CAPTCHA solved and session saved"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/copilot/captcha/clear")
+async def copilot_captcha_clear():
+    """Clear the CAPTCHA pending state (for retry)."""
+    try:
+        from providers.copilot_provider import CopilotProvider
+        
+        # Get context and close it
+        context = CopilotProvider.get_captcha_context()
+        if context:
+            await context.close()
+        
+        CopilotProvider.clear_captcha_pending()
+        
+        return {
+            "status": "success",
+            "message": "CAPTCHA state cleared"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/copilot/session/status")
+async def copilot_session_status():
+    """Check Copilot session status."""
+    try:
+        from copilot_session import CopilotSessionManager
+        
+        session_info = CopilotSessionManager.get_session_info()
+        return session_info
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

config.py

@@ -20,7 +20,10 @@ MODEL_RANKING = [
     ("zai-glm-5", "zai", "glm-5"),
     ("gemini-gemini-3-flash", "gemini", "gemini-3-flash"),
     
-    # Tier 2 — HuggingChat Models (Top 20 by popularity/quality)
+    # Tier 2 — Copilot (GPT-4 via Microsoft)
+    ("copilot-gpt-4", "copilot", "copilot-gpt-4"),
+    
+    # Tier 3 — HuggingChat Models (Top 20 by popularity/quality)
     ("huggingchat-omni", "huggingchat", "omni"),
     ("huggingchat-llama-3.3-70b", "huggingchat", "meta-llama/Llama-3.3-70B-Instruct"),
     ("huggingchat-llama-4-scout", "huggingchat", "meta-llama/Llama-4-Scout-17B-16E-Instruct"),
@@ -178,6 +181,9 @@ PROVIDER_MODELS = {
     "gemini": [
         "gemini-gemini-3-flash",
     ],
+    "copilot": [
+        "copilot-gpt-4",
+    ],
     "huggingchat": [
         # Top Tier
         "huggingchat-omni",

copilot_session.py

@@ -0,0 +1,119 @@
+"""
+Copilot Session Manager
+-----------------------
+Manages persistent browser sessions and cookies for Microsoft Copilot.
+Unlike HuggingChat, this has NO conversation limit - sessions persist indefinitely.
+"""
+
+import json
+import logging
+import os
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger("kai_api.copilot_session")
+
+# Storage file for Copilot session
+SESSION_FILE = "/tmp/copilot_session.json"
+
+
+class CopilotSessionManager:
+    """Manages Copilot browser session persistence - unlimited conversations."""
+
+    @staticmethod
+    def save_cookies(cookies: list, user_agent: str = None) -> bool:
+        """
+        Save cookies from an authenticated session.
+        
+        Args:
+            cookies: List of cookie dictionaries from Playwright
+            user_agent: User agent string used during authentication
+        
+        Returns:
+            bool: True if saved successfully
+        """
+        try:
+            session_data = {
+                "cookies": cookies,
+                "user_agent": user_agent,
+                "timestamp": datetime.now().isoformat(),
+                "expires_at": (datetime.now() + timedelta(days=30)).isoformat(),  # 30 days
+            }
+            
+            with open(SESSION_FILE, "w") as f:
+                json.dump(session_data, f, indent=2)
+            
+            logger.info(f"✅ Saved {len(cookies)} cookies for Copilot session")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to save Copilot cookies: {e}")
+            return False
+
+    @staticmethod
+    def load_session() -> Optional[dict]:
+        """
+        Load saved session data if it exists and is not expired.
+        
+        Returns:
+            dict with cookies and user_agent, or None if no valid session
+        """
+        try:
+            if not os.path.exists(SESSION_FILE):
+                return None
+            
+            with open(SESSION_FILE, "r") as f:
+                session_data = json.load(f)
+            
+            # Check expiration (30 days)
+            expires_at = datetime.fromisoformat(session_data.get("expires_at", "2000-01-01"))
+            if datetime.now() > expires_at:
+                logger.info("Copilot session expired, need re-authentication")
+                return None
+            
+            logger.info(f"✅ Loaded Copilot session (expires: {expires_at})")
+            return session_data
+            
+        except Exception as e:
+            logger.error(f"Failed to load Copilot cookies: {e}")
+            return None
+
+    @staticmethod
+    def clear_session() -> bool:
+        """Clear the saved session."""
+        try:
+            if os.path.exists(SESSION_FILE):
+                os.remove(SESSION_FILE)
+                logger.info("✅ Cleared Copilot session")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to clear Copilot session: {e}")
+            return False
+
+    @staticmethod
+    def has_valid_session() -> bool:
+        """Check if we have a valid authenticated session."""
+        session = CopilotSessionManager.load_session()
+        return session is not None and len(session.get("cookies", [])) > 0
+
+    @staticmethod
+    def get_session_info() -> dict:
+        """Get information about the current session."""
+        session = CopilotSessionManager.load_session()
+        
+        if not session:
+            return {
+                "has_session": False,
+                "message": "No session found. May need CAPTCHA verification.",
+            }
+        
+        expires_at = datetime.fromisoformat(session.get("expires_at", "2000-01-01"))
+        time_left = expires_at - datetime.now()
+        
+        return {
+            "has_session": True,
+            "expires_at": session.get("expires_at"),
+            "days_remaining": max(0, time_left.days),
+            "cookie_count": len(session.get("cookies", [])),
+            "timestamp": session.get("timestamp"),
+        }

engine.py

@@ -20,6 +20,7 @@ from providers.pollinations_provider import PollinationsProvider
 from providers.gemini_provider import GeminiProvider
 from providers.zai_provider import ZaiProvider
 from providers.huggingchat_provider import HuggingChatProvider
+from providers.copilot_provider import CopilotProvider
 from config import MODEL_RANKING, PROVIDER_MODELS, SUPABASE_URL, SUPABASE_KEY
 from models import ModelInfo
 from sanitizer import sanitize_response
@@ -61,8 +62,12 @@ class AIEngine:
             # HuggingChat also uses Playwright
             self._providers["huggingchat"] = HuggingChatProvider()
             logger.info("✅ HuggingChat provider enabled")
+            
+            # Copilot also uses Playwright (with CAPTCHA support)
+            self._providers["copilot"] = CopilotProvider()
+            logger.info("✅ Copilot provider enabled (with CAPTCHA support)")
         else:
-            logger.warning("⚠️ Z.ai/Gemini/HuggingChat providers disabled (Playwright not installed)")
+            logger.warning("⚠️ Z.ai/Gemini/HuggingChat/Copilot providers disabled (Playwright not installed)")
         # Success Tracker: Key = "provider/model_id"
         # Value = {success, failure, consecutive_failures, avg_time_ms, total_time_ms, count_samples}
         self._stats: dict[str, dict] = {}

providers/copilot_provider.py

@@ -0,0 +1,333 @@
+"""
+Microsoft Copilot Provider (Browser-Based with CAPTCHA Support)
+---------------------------------------------------------------
+Uses Playwright Chromium to interact with https://copilot.microsoft.com/ as a real browser.
+
+Strategy:
+- Uses persistent browser context with stored cookies
+- Handles CAPTCHA by detecting it and returning special status
+- Shows CAPTCHA challenge in admin dashboard (/qazmlp)
+- Unlimited conversations (no 50 limit)
+- Starts new chat for each request (no context sharing)
+"""
+
+import asyncio
+import logging
+import re
+from typing import Optional, Dict, Any
+from providers.base import BaseProvider
+from config import PROVIDER_MODELS
+from copilot_session import CopilotSessionManager
+
+logger = logging.getLogger("kai_api.copilot")
+
+_playwright = None
+_browser = None
+_lock = asyncio.Lock()
+
+# Track if we're currently showing CAPTCHA
+_captcha_pending = False
+_captcha_context = None
+
+
+class CopilotProvider(BaseProvider):
+    """AI provider using Microsoft Copilot via Persistent Playwright Browser."""
+
+    RESPONSE_TIMEOUT = 90
+    HYDRATION_DELAY = 3.0
+
+    @property
+    def name(self) -> str:
+        return "copilot"
+
+    def get_available_models(self) -> list[str]:
+        return PROVIDER_MODELS.get("copilot", ["copilot-gpt-4"])
+
+    @staticmethod
+    def is_available() -> bool:
+        """Check if Playwright is installed and usable."""
+        try:
+            from playwright.async_api import async_playwright
+            return True
+        except ImportError:
+            return False
+
+    async def _ensure_browser(self):
+        """Start the persistent browser if it's not running."""
+        global _playwright, _browser
+
+        async with _lock:
+            if _browser and _browser.is_connected():
+                return
+
+            logger.info("🚀 Copilot: Launching Persistent Browser...")
+            from playwright.async_api import async_playwright
+
+            _playwright = await async_playwright().start()
+            _browser = await _playwright.chromium.launch(
+                headless=True,
+                args=[
+                    "--disable-blink-features=AutomationControlled",
+                    "--no-sandbox",
+                    "--disable-dev-shm-usage",
+                    "--disable-gpu",
+                    "--disable-web-security",
+                    "--disable-features=IsolateOrigins,site-per-process",
+                ],
+            )
+            logger.info("✅ Copilot: Browser is Ready.")
+
+    async def _check_and_handle_captcha(self, page) -> bool:
+        """
+        Check if CAPTCHA is present on the page.
+        Returns True if CAPTCHA detected, False otherwise.
+        """
+        try:
+            # Multiple CAPTCHA selectors
+            captcha_selectors = [
+                '[data-testid="captcha-challenge"]',
+                'iframe[src*="captcha"]',
+                'input[id*="captcha"]',
+                '.captcha-container',
+                '[class*="captcha"]',
+                'text="Verify you"',
+                'text="I\'m not a robot"',
+                'text="Security check"',
+                '#challenge-form',
+                '.challenge-container',
+            ]
+            
+            for selector in captcha_selectors:
+                try:
+                    element = await page.wait_for_selector(selector, timeout=3000)
+                    if element and await element.is_visible():
+                        logger.warning("🤖 Copilot: CAPTCHA detected!")
+                        return True
+                except:
+                    continue
+            
+            return False
+        except Exception as e:
+            logger.error(f"Error checking for CAPTCHA: {e}")
+            return False
+
+    async def send_message(
+        self,
+        prompt: str,
+        model: str | None = None,
+        system_prompt: str | None = None,
+        **kwargs,
+    ) -> dict:
+        """Send a message via Copilot browser automation."""
+        if not self.is_available():
+            raise RuntimeError("Playwright not installed.")
+
+        await self._ensure_browser()
+        selected_model = model or "copilot-gpt-4"
+        session_mgr = CopilotSessionManager()
+
+        # Check if we have a valid session
+        session_data = session_mgr.load_session()
+        
+        # Create context with cookies if we have them
+        context = await _browser.new_context(
+            viewport={"width": 1920, "height": 1080},
+            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0",
+            locale="en-US",
+            timezone_id="America/New_York",
+        )
+
+        # Hide webdriver flag
+        await context.add_init_script("""
+            Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
+            Object.defineProperty(navigator, 'plugins', {get: () => [1, 2, 3, 4, 5]});
+            window.chrome = { runtime: {} };
+        """)
+
+        # Add cookies if we have them
+        if session_data and session_data.get("cookies"):
+            await context.add_cookies(session_data["cookies"])
+            logger.info("✅ Copilot: Loaded existing session cookies")
+
+        page = await context.new_page()
+
+        try:
+            logger.info(f"Copilot request: {selected_model}")
+
+            # Navigate to Copilot
+            await page.goto("https://copilot.microsoft.com/", timeout=60000)
+            await asyncio.sleep(3)
+
+            # Check for CAPTCHA
+            has_captcha = await self._check_and_handle_captcha(page)
+            
+            if has_captcha:
+                logger.warning("🤖 Copilot: CAPTCHA challenge detected!")
+                
+                # Save current state for CAPTCHA solving
+                global _captcha_pending, _captcha_context
+                _captcha_pending = True
+                _captcha_context = context
+                
+                # Take screenshot for admin dashboard
+                screenshot_path = "/tmp/copilot_captcha.png"
+                await page.screenshot(path=screenshot_path, full_page=True)
+                
+                raise Exception("CAPTCHA_REQUIRED")
+
+            # Try to start a new chat (clear previous context)
+            try:
+                new_chat_btn = await page.wait_for_selector('button:has-text("New chat")', timeout=5000)
+                if new_chat_btn:
+                    await new_chat_btn.click()
+                    await asyncio.sleep(2)
+                    logger.info("Copilot: Started new chat")
+            except:
+                logger.info("Copilot: No 'New chat' button found, continuing...")
+
+            # Find and use the chat input
+            input_selectors = [
+                '[data-testid="chat-input"]',
+                'div[contenteditable="true"]',
+                '[role="textbox"]',
+                'textarea',
+                '.input-area div[contenteditable]',
+            ]
+
+            input_selector = None
+            for sel in input_selectors:
+                try:
+                    await page.wait_for_selector(sel, timeout=5000)
+                    input_selector = sel
+                    logger.info(f"✅ Copilot: Found input selector: {sel}")
+                    break
+                except:
+                    continue
+
+            if not input_selector:
+                raise RuntimeError("Could not find Copilot chat input")
+
+            await asyncio.sleep(self.HYDRATION_DELAY)
+
+            # Type the message
+            full_prompt = prompt
+            if system_prompt:
+                full_prompt = f"[System: {system_prompt}]\n\n{prompt}"
+
+            await page.click(input_selector)
+            await page.keyboard.type(full_prompt, delay=10)
+            await asyncio.sleep(0.5)
+            await page.keyboard.press("Enter")
+
+            logger.info("Copilot: Message sent...")
+
+            # Wait for response
+            response_text = await self._wait_for_response(page)
+
+            if not response_text:
+                raise ValueError("Empty response from Copilot")
+
+            # Save cookies after successful request
+            cookies = await context.cookies()
+            session_mgr.save_cookies(cookies)
+            logger.info("✅ Copilot: Saved session cookies")
+
+            return {
+                "response": response_text,
+                "model": selected_model,
+            }
+
+        except Exception as e:
+            if "CAPTCHA_REQUIRED" in str(e):
+                raise
+            logger.error(f"Copilot Error: {e}")
+            raise
+        finally:
+            if not _captcha_pending:  # Only close if no CAPTCHA pending
+                await context.close()
+
+    async def _wait_for_response(self, page) -> str:
+        """Wait for and extract the AI response from the DOM."""
+        last_text = ""
+        stable_count = 0
+        required_stable = 4
+
+        for i in range(self.RESPONSE_TIMEOUT * 2):
+            await asyncio.sleep(0.5)
+
+            # Extract response text
+            current_text = await page.evaluate("""
+                () => {
+                    const selectors = [
+                        '[data-testid="assistant-message"]',
+                        '.message-content',
+                        '[data-message-author-role="assistant"]',
+                        '.ac-textBlock',
+                        '[class*="response"]',
+                        '[class*="message"] div',
+                        '.markdown-body',
+                    ];
+                    
+                    for (const sel of selectors) {
+                        const els = document.querySelectorAll(sel);
+                        if (els.length > 0) {
+                            const last = els[els.length - 1];
+                            const text = last.innerText || last.textContent || '';
+                            if (text.trim().length > 10) return text.trim();
+                        }
+                    }
+                    return '';
+                }
+            """)
+
+            if not current_text:
+                continue
+
+            # Clean the text
+            clean = self._clean_response(current_text)
+
+            if clean == last_text and len(clean) > 0:
+                stable_count += 1
+                if stable_count >= required_stable:
+                    return clean
+            else:
+                stable_count = 0
+                last_text = clean
+
+            if i % 10 == 9:
+                logger.info(f"Copilot: Stream... {len(last_text)} chars")
+
+        if last_text:
+            logger.warning("Copilot: Timeout, returning partial.")
+            return last_text
+
+        raise TimeoutError("Copilot no response")
+
+    def _clean_response(self, text: str) -> str:
+        """Clean up Copilot response text."""
+        clean = text.strip()
+
+        # Remove common UI artifacts
+        clean = re.sub(r"^(Copilot\s*|Microsoft Copilot\s*)", "", clean, flags=re.IGNORECASE)
+        clean = re.sub(r"\n+\s*\n+", "\n\n", clean)
+
+        return clean.strip()
+
+    @staticmethod
+    def is_captcha_pending() -> bool:
+        """Check if there's a pending CAPTCHA challenge."""
+        global _captcha_pending
+        return _captcha_pending
+
+    @staticmethod
+    def get_captcha_context():
+        """Get the browser context with pending CAPTCHA."""
+        global _captcha_context
+        return _captcha_context
+
+    @staticmethod
+    def clear_captcha_pending():
+        """Clear the CAPTCHA pending state."""
+        global _captcha_pending, _captcha_context
+        _captcha_pending = False
+        _captcha_context = None

static/qaz.html

@@ -521,6 +521,112 @@
                 lookupToken();
             }
         });
+        
+        // Copilot CAPTCHA handling
+        async function checkCopilotCaptchaStatus() {
+            try {
+                const res = await fetch('/qaz/copilot/captcha/status');
+                const data = await res.json();
+                
+                if (data.captcha_required) {
+                    document.getElementById('copilot-captcha-section').style.display = 'block';
+                    document.getElementById('copilot-captcha-img').src = data.screenshot_url + '?t=' + new Date().getTime();
+                } else {
+                    document.getElementById('copilot-captcha-section').style.display = 'none';
+                }
+            } catch (e) {
+                console.error('Failed to check Copilot CAPTCHA status:', e);
+            }
+        }
+        
+        async function markCaptchaSolved() {
+            try {
+                const res = await fetch('/qaz/copilot/captcha/solved', { method: 'POST' });
+                const data = await res.json();
+                alert(data.message);
+                document.getElementById('copilot-captcha-section').style.display = 'none';
+            } catch (e) {
+                alert('Error: ' + e.message);
+            }
+        }
+        
+        async function clearCaptchaState() {
+            if (!confirm('Clear CAPTCHA state and retry?')) return;
+            try {
+                const res = await fetch('/qaz/copilot/captcha/clear', { method: 'POST' });
+                const data = await res.json();
+                alert(data.message);
+                document.getElementById('copilot-captcha-section').style.display = 'none';
+            } catch (e) {
+                alert('Error: ' + e.message);
+            }
+        }
+        
+        // Check CAPTCHA status periodically
+        checkCopilotCaptchaStatus();
+        setInterval(checkCopilotCaptchaStatus, 10000);
+    </script>
+    
+    <!-- Copilot CAPTCHA Section -->
+    <div id="copilot-captcha-section" class="card" style="margin-top: 30px; display: none; border: 2px solid var(--warning);">
+        <h2 style="color: var(--warning); margin-bottom: 15px;">⚠️ Copilot CAPTCHA Required</h2>
+        <p style="color: var(--text-muted); margin-bottom: 20px;">
+            Microsoft Copilot is requesting a CAPTCHA verification. Please solve it below, then click "I've Solved It".
+        </p>
+        
+        <div style="background: var(--bg); border: 1px solid var(--border); border-radius: 8px; padding: 20px; margin-bottom: 20px;">
+            <img id="copilot-captcha-img" src="" alt="CAPTCHA Screenshot" style="max-width: 100%; border-radius: 4px; display: block; margin: 0 auto;">
+        </div>
+        
+        <div style="display: flex; gap: 10px;">
+            <button onclick="markCaptchaSolved()" style="background: var(--success); color: white; border: none; padding: 12px 24px; border-radius: 6px; font-weight: 600; cursor: pointer; flex: 1;">
+                ✅ I've Solved It
+            </button>
+            <button onclick="checkCopilotCaptchaStatus()" style="background: var(--accent); color: white; border: none; padding: 12px 24px; border-radius: 6px; font-weight: 600; cursor: pointer;">
+                🔄 Refresh Screenshot
+            </button>
+            <button onclick="clearCaptchaState()" style="background: transparent; color: var(--error); border: 1px solid var(--error); padding: 12px 24px; border-radius: 6px; font-weight: 600; cursor: pointer;">
+                🗑️ Clear & Retry
+            </button>
+        </div>
+    </div>
+    
+    <!-- Copilot Session Status -->
+    <div class="card" style="margin-top: 30px;">
+        <h2 style="margin-bottom: 15px;">Copilot Session Status</h2>
+        <div id="copilot-session-info" style="color: var(--text-muted);">
+            <button onclick="checkCopilotSession()" style="background: var(--accent); color: white; border: none; padding: 8px 16px; border-radius: 6px; cursor: pointer;">Check Status</button>
+        </div>
+    </div>
+    
+    <script>
+        async function checkCopilotSession() {
+            try {
+                const res = await fetch('/qaz/copilot/session/status');
+                const data = await res.json();
+                
+                const infoDiv = document.getElementById('copilot-session-info');
+                if (data.has_session) {
+                    infoDiv.innerHTML = `
+                        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px;">
+                            <div><strong>Status:</strong> <span style="color: var(--success);">✅ Active</span></div>
+                            <div><strong>Cookies:</strong> ${data.cookie_count}</div>
+                            <div><strong>Days Remaining:</strong> ${data.days_remaining}</div>
+                            <div><strong>Expires:</strong> ${new Date(data.expires_at).toLocaleDateString()}</div>
+                        </div>
+                        <button onclick="checkCopilotSession()" style="background: var(--accent); color: white; border: none; padding: 8px 16px; border-radius: 6px; cursor: pointer; margin-top: 15px;">Refresh</button>
+                    `;
+                } else {
+                    infoDiv.innerHTML = `
+                        <div><strong>Status:</strong> <span style="color: var(--error);">❌ No Active Session</span></div>
+                        <p style="margin-top: 10px; font-size: 13px;">${data.message}</p>
+                        <button onclick="checkCopilotSession()" style="background: var(--accent); color: white; border: none; padding: 8px 16px; border-radius: 6px; cursor: pointer; margin-top: 10px;">Refresh</button>
+                    `;
+                }
+            } catch (e) {
+                document.getElementById('copilot-session-info').innerHTML = '<span style="color: var(--error);">Error checking status</span>';
+            }
+        }
     </script>
 </body>