@ojas-sta/qalify-plus 1.1.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,52 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/README.md

@@ -0,0 +1,106 @@
+# Qalify+ & Vulnerability Simulator
+
+An educational toolkit demonstrating how modern web quizzes can be analyzed and automated using AI (Gemini 2.5 Flash), DOM extraction, and OCR (Tesseract.js). 
+
+This project explores the security boundaries of online assessments by highlighting how easily DOM-based quizzes can be read, and how even obfuscated (Canvas/Image-based) questions can be bypassed using automated screenshots and Optical Character Recognition (OCR).
+
+---
+
+## 🚀 Features
+
+*   **Generic Playwright Overlay (`src/generic.js`):** Injects a sleek, interactive dark-mode UI overlay into **any** website you visit. It provides dual-mode extraction:
+    *   **Analyze (DOM):** Instantly extracts the text from standard HTML web pages.
+    *   **Analyze (OCR):** Takes a background screenshot, sharpens the image, and runs it through Tesseract.js to defeat anti-scraping canvas/image obfuscation.
+*   **Interactive AI Chatbot:** After extracting a question, the UI allows you to chat directly with the AI to ask follow-up questions or have it explain its reasoning.
+*   **Multi-Model Support:** Integrates with both Google Gemini and OpenRouter, allowing you to seamlessly swap between models optimized for math (Qwen), academia (Owl Alpha), or coding (Laguna).
+*   **Native Markdown Rendering:** Chat bubbles and reasoning outputs natively parse LLM Markdown into clean HTML (bolding, lists, code blocks).
+*   **Anti-Inception Capture:** The UI overlay automatically hides itself in a fraction of a millisecond during screen capture to prevent the AI from "reading" its own UI elements.
+*   **Chrome Extension Version:** A lightweight Manifest V3 Chrome Extension version of the DOM analyzer, ready for unlisted publishing.
+*   **Local Autonomous Loop (`src/main.js`):** An automated loop that navigates a local test quiz, continuously identifying questions, selecting the best AI-determined answer, and auto-clicking the "Next" button.
+
+---
+
+## 🔑 Getting Your API Keys (Required)
+
+To power the AI analysis, you will need at least one API key. You can get both entirely for free!
+
+### 1. Google Gemini API Key (Recommended for General Use)
+Gemini 2.5 Flash is incredibly fast, smart, and provides a very generous free tier.
+*   **Link:** [Google AI Studio API Keys](https://aistudio.google.com/app/apikey)
+*   **How to get it:**
+    1. Click the link above and sign in with your Google Account.
+    2. Click the blue **"Create API key"** button on the screen.
+    3. Select a project (or create a new one) and generate the key.
+    4. Copy your key (it usually starts with `AIza...`).
+
+### 2. OpenRouter API Key (Recommended for Specialized Models)
+OpenRouter gives you access to hundreds of open-source models, including powerful free models specifically optimized for Math (Qwen) and Academia (Owl Alpha).
+*   **Link:** [OpenRouter API Keys](https://openrouter.ai/settings/keys)
+*   **How to get it:**
+    1. Create a free account on OpenRouter.
+    2. Navigate to your settings and click **"Create Key"**.
+    3. Give the key a name (e.g., "Quiz Assistant").
+    4. Copy the key (it starts with `sk-or-v1-...`). *Note: Make sure you copy it immediately, as it is only shown once!*
+
+---
+
+## 📦 Setup & Installation
+
+You do not need to download the code to use the assistant! It has been published globally to the NPM registry.
+
+1. **Ensure Node.js is installed:** Make sure you have [Node.js](https://nodejs.org/) (v18+) installed on your machine.
+2. **Install Playwright Browsers (One-time setup):**
+   Because the assistant uses a hidden browser to read and analyze quizzes, you need to install the browser engine first:
+   ```bash
+   npx playwright install chromium
+   ```
+3. **Run the universal command:**
+   Open your terminal and type:
+   ```bash
+   npx @ojas-sta/qalify-plus@latest https://google.com
+   ```
+4. **Interactive Setup:** On your very first run, the tool will automatically pause and ask you to paste the API keys you generated above. It securely saves them so you never have to enter them again!
+
+---
+
+## 🕹️ Usage Guide
+
+### Mode 1: The Universal UI Overlay (Recommended)
+This mode launches a custom browser, navigates to a URL you specify, and injects our custom Qalify+ overlay into the page.
+
+```bash
+npx @ojas-sta/qalify-plus@latest "https://example-quiz-site.com/login"
+```
+*   **How to use:** Navigate the browser manually (log in, pass captchas, etc.). When a question is on screen, click either the **DOM** or **OCR** analyze buttons in the floating overlay.
+*   **Chat:** After an analysis, a chat window will slide down allowing you to interrogate the AI about its answer.
+
+### Mode 2: Chrome Extension (DOM-only)
+A lightweight version you can install directly into your primary Chrome browser. Because of Chrome Web Store security limits on screenshots and WASM models, this version only uses DOM extraction (no OCR).
+
+1. Open Chrome and navigate to `chrome://extensions`.
+2. Turn on **Developer mode** (top right).
+3. Click **Load unpacked** (top left).
+4. Select the `chrome-extension` folder inside this project.
+5. Click the extension icon in your browser to open the Side Panel. Don't forget to paste your API Key into the settings!
+
+### Mode 3: The Autonomous Local Simulator
+This runs an aggressive automated bot against a local test file (`test/quiz.html`). It auto-detects questions, selects radio buttons, and advances to the next page entirely on its own.
+
+```bash
+node src/main.js
+```
+
+---
+
+## 🏗️ Architecture & Modules
+
+*   **`src/ai.js`:** Wraps the Gemini 2.5 API. Uses strict JSON Schema to force the LLM to return `selectedOption`, `confidenceScore`, and `reasoning`. Also maintains chat history for follow-ups.
+*   **`src/ocr.js`:** The heavy lifting. Takes a raw Playwright screenshot, uses Jimp to increase contrast and greyscale the image, and feeds it into the Tesseract.js engine to extract raw text.
+*   **`src/analyzer.js`:** Orchestrates the flow between extracting text, querying the AI, and parsing the response.
+*   **`src/browser.js`:** The autonomous Playwright controller that hunts for specific DOM selectors like `.question-text` and `#next-btn`.
+
+---
+
+## ⚠️ Disclaimer
+
+**Educational Purposes Only.** This toolkit was developed to demonstrate the vulnerabilities inherent in client-side web assessments and to explore the defensive boundaries of CAPTCHAs, Canvas obfuscation, and DOM scraping. Do not use these tools to violate the terms of service of third-party platforms or to bypass academic integrity policies.

package/chrome-extension/CHROMEWEBSTORE.md

@@ -0,0 +1,50 @@
+# Chrome Web Store Metadata: Quiz Assistant
+
+## 1. Store Listing Copy
+
+**Title:** Quiz Assistant (Max 45 chars)
+**Short Description:** An interactive AI assistant that analyzes active web pages to identify and explain educational quiz questions. (Max 132 chars)
+
+**Detailed Description:**
+Quiz Assistant is an educational tool designed to help you understand complex questions and study material on the web. By opening the side panel, the assistant analyzes the text of the page you are currently viewing. If it identifies a quiz question or a learning scenario, it leverages advanced AI to provide a suggested answer along with a detailed, plain-English explanation of its reasoning.
+
+Features:
+- **One-Click Analysis:** Instantly reads the text on your current tab.
+- **AI-Powered Reasoning:** Provides clear explanations for why a specific answer is correct, helping you learn rather than just guessing.
+- **Interactive Chatbot:** Ask follow-up questions directly in the side panel to dive deeper into the topic.
+- **Privacy First:** You provide your own API key which is stored securely in your browser's local storage. The extension only analyzes the page when you explicitly click the "Analyze" button.
+
+*Note: You must provide your own Gemini API Key to use this extension.*
+
+## 2. Permissions Justification
+
+| Permission | Justification |
+| :--- | :--- |
+| `activeTab` | Required to allow the extension to read the text of the currently active tab when the user clicks the "Analyze Active Page" button. |
+| `scripting` | Required to execute a script that extracts the `document.body.innerText` from the active tab so the AI can analyze the content. |
+| `sidePanel` | Required to host the extension's interactive chat and analysis UI in the browser's native side panel. |
+| `storage` | Required to securely save the user's provided Gemini API key locally on their device so they do not have to re-enter it every time. |
+
+### Host Permissions
+| Host | Justification |
+| :--- | :--- |
+| `<all_urls>` | Required because the user might need educational assistance or question analysis on any website or domain they are currently studying on. |
+
+## 3. Privacy Policy & Data Use
+
+**Does this extension collect or use user data?**
+Yes.
+
+**Data Collection & Usage:**
+1. **API Keys:** The extension asks for your Gemini API key. This key is stored entirely locally on your device using `chrome.storage.local`. It is never transmitted to our servers or any third-party other than Google's official Gemini API endpoint for the purpose of fulfilling your chat requests.
+2. **Web Page Content:** When you explicitly click "Analyze Active Page", the extension reads the text of the web page you are currently viewing. This text is sent directly to the Google Gemini API to generate an analysis. We do not store, log, or track your browsing history or the content of the pages you analyze.
+
+**Data Retention:**
+We do not operate any backend servers. All data (API keys and chat history) is stored locally within your Chrome browser profile and is cleared when you uninstall the extension or clear your extension data.
+
+## 4. Pre-Publish Checklist
+- [x] manifest.json is V3
+- [x] All permissions justified
+- [x] Privacy policy documented
+- [ ] Create 1280x800 promotional image
+- [ ] Create 128x128 icon file (currently omitted from manifest for development)

package/chrome-extension/background.js

@@ -0,0 +1,3 @@
+chrome.action.onClicked.addListener(async (tab) => {
+  await chrome.sidePanel.open({ windowId: tab.windowId });
+});

package/chrome-extension/manifest.json

@@ -0,0 +1,21 @@
+{
+  "manifest_version": 3,
+  "name": "Quiz Assistant",
+  "version": "1.0.0",
+  "description": "An interactive AI assistant that analyzes quiz questions on the current page and provides reasoning.",
+  "permissions": [
+    "activeTab",
+    "scripting",
+    "sidePanel",
+    "storage"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "action": {
+    "default_title": "Open Quiz Assistant"
+  },
+  "background": {
+    "service_worker": "background.js"
+  }
+}

package/chrome-extension/sidepanel.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <style>
+    body { font-family: system-ui, sans-serif; background: #1e1e1e; color: #f0f0f0; padding: 16px; margin: 0; }
+    h2 { color: #4caf50; margin-top: 0; }
+    button { background: #4caf50; color: white; border: none; padding: 8px 12px; border-radius: 4px; cursor: pointer; width: 100%; font-weight: bold; margin-bottom: 16px; }
+    button:hover { background: #45a049; }
+    input[type="password"], input[type="text"] { width: 100%; padding: 8px; margin-bottom: 16px; box-sizing: border-box; background: #333; color: white; border: 1px solid #555; border-radius: 4px; }
+    .card { background: #2a2a2a; border-radius: 8px; padding: 12px; margin-bottom: 16px; border: 1px solid #444; }
+    .hidden { display: none; }
+    #chat-history { height: 200px; overflow-y: auto; margin-bottom: 12px; font-size: 0.9em; border: 1px solid #444; padding: 8px; border-radius: 4px; background: #222; }
+    #chat-input-container { display: flex; }
+    #chat-input { flex-grow: 1; margin-bottom: 0; margin-right: 8px; }
+    #chat-send { width: auto; margin-bottom: 0; }
+  </style>
+</head>
+<body>
+  <h2>Quiz Assistant</h2>
+  
+  <div id="setup-section">
+    <p style="font-size: 0.9em; color: #ccc;">Please enter your Gemini API Key. It will be stored securely in your browser's local storage.</p>
+    <label for="api-key" style="display:block; margin-bottom: 5px;">Gemini API Key:</label>
+    <input type="password" id="api-key" placeholder="AIzaSy...">
+    <button id="save-key-btn">Save Key</button>
+  </div>
+
+  <div id="main-section" class="hidden">
+    <button id="analyze-btn">Analyze Active Page</button>
+    
+    <div id="result-card" class="card hidden">
+      <p><strong>Suggested Option:</strong> <span id="res-option"></span></p>
+      <p><strong>Confidence:</strong> <span id="res-confidence"></span>%</p>
+      <p style="font-size: 0.9em; color: #aaa;"><strong>Reasoning:</strong><br/><span id="res-reasoning"></span></p>
+    </div>
+
+    <div class="card">
+      <h3 style="margin-top:0; font-size: 1em;">Chat</h3>
+      <div id="chat-history"></div>
+      <div id="chat-input-container">
+        <input type="text" id="chat-input" placeholder="Ask follow-up...">
+        <button id="chat-send">Send</button>
+      </div>
+    </div>
+  </div>
+
+  <script src="sidepanel.js"></script>
+</body>
+</html>

package/chrome-extension/sidepanel.js

@@ -0,0 +1,127 @@
+let apiKey = '';
+let chatHistory = [];
+
+document.addEventListener('DOMContentLoaded', async () => {
+    const data = await chrome.storage.local.get('apiKey');
+    if (data.apiKey) {
+        apiKey = data.apiKey;
+        document.getElementById('setup-section').classList.add('hidden');
+        document.getElementById('main-section').classList.remove('hidden');
+    }
+
+    document.getElementById('save-key-btn').addEventListener('click', async () => {
+        const key = document.getElementById('api-key').value.trim();
+        if (key) {
+            await chrome.storage.local.set({ apiKey: key });
+            apiKey = key;
+            document.getElementById('setup-section').classList.add('hidden');
+            document.getElementById('main-section').classList.remove('hidden');
+        }
+    });
+
+    document.getElementById('analyze-btn').addEventListener('click', analyzePage);
+    document.getElementById('chat-send').addEventListener('click', sendChatMessage);
+    document.getElementById('chat-input').addEventListener('keypress', (e) => {
+        if (e.key === 'Enter') sendChatMessage();
+    });
+});
+
+async function analyzePage() {
+    const btn = document.getElementById('analyze-btn');
+    btn.textContent = "Analyzing...";
+    btn.disabled = true;
+
+    try {
+        const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+        
+        // Execute script to extract text from the active tab
+        const [{ result }] = await chrome.scripting.executeScript({
+            target: { tabId: tab.id },
+            func: () => document.body.innerText
+        });
+
+        const pageText = result;
+
+        const prompt = `
+You are an expert acting as an educational assistant.
+Here is the text extracted from the webpage:
+${pageText.substring(0, 5000)}
+
+Based on your knowledge, identify if there is a quiz question present. If so, determine the most correct option.
+Return a JSON object with the following schema:
+{"selectedOption": "A", "confidenceScore": 100, "reasoning": "brief explanation"}
+If no clear question is found, return "N/A" for selectedOption and explain why in reasoning.
+`;
+
+        chatHistory = [{ role: "user", parts: [{ text: prompt }] }];
+
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                contents: chatHistory,
+                generationConfig: { responseMimeType: "application/json" }
+            })
+        });
+
+        const data = await response.json();
+        
+        if (data.error) throw new Error(data.error.message);
+
+        const rawText = data.candidates[0].content.parts[0].text;
+        chatHistory.push(data.candidates[0].content); // save to history
+
+        const parsed = JSON.parse(rawText);
+        
+        document.getElementById('result-card').classList.remove('hidden');
+        document.getElementById('res-option').textContent = parsed.selectedOption;
+        document.getElementById('res-confidence').textContent = parsed.confidenceScore;
+        document.getElementById('res-reasoning').textContent = parsed.reasoning;
+
+        const chatUI = document.getElementById('chat-history');
+        chatUI.innerHTML += `<div style="margin-bottom:8px; color:#4caf50;"><b>AI:</b> Analysis complete. I selected Option ${parsed.selectedOption}. Ask me any questions!</div>`;
+
+    } catch (e) {
+        alert("Error analyzing page: " + e.message);
+    } finally {
+        btn.textContent = "Analyze Active Page";
+        btn.disabled = false;
+    }
+}
+
+async function sendChatMessage() {
+    const input = document.getElementById('chat-input');
+    const msg = input.value.trim();
+    if (!msg) return;
+
+    input.value = '';
+    input.disabled = true;
+    
+    const chatUI = document.getElementById('chat-history');
+    chatUI.innerHTML += `<div style="margin-bottom:8px;"><b>You:</b> ${msg}</div>`;
+    chatUI.scrollTop = chatUI.scrollHeight;
+
+    chatHistory.push({ role: "user", parts: [{ text: msg }] });
+
+    try {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ contents: chatHistory })
+        });
+
+        const data = await response.json();
+        if (data.error) throw new Error(data.error.message);
+
+        const aiMsg = data.candidates[0].content.parts[0].text;
+        chatHistory.push(data.candidates[0].content);
+
+        chatUI.innerHTML += `<div style="margin-bottom:8px; color:#4caf50;"><b>AI:</b> ${aiMsg}</div>`;
+    } catch (e) {
+        chatUI.innerHTML += `<div style="margin-bottom:8px; color:red;"><b>Error:</b> ${e.message}</div>`;
+    } finally {
+        input.disabled = false;
+        input.focus();
+        chatUI.scrollTop = chatUI.scrollHeight;
+    }
+}

package/feature_timeline.md

@@ -0,0 +1,19 @@
+# Feature Timeline: AI Quiz Assistant
+
+## ✅ Completed Features
+- **Core Automation:** Basic Playwright autonomous loop to auto-click and auto-navigate quizzes.
+- **Visual Analysis:** OCR implementation via Tesseract.js & Jimp image preprocessing.
+- **Browser Portability:** Chrome Extension (Manifest V3) version for standard DOM extraction.
+- **Universal Overlay:** Generic Playwright UI overlay injection for testing on any website.
+- **Interactive Chat:** In-browser LLM Chatbot via Playwright function exposure.
+- **Multi-Model Support:** OpenRouter API integration supporting Academic/Code/Math specific models (Owl Alpha, Qwen, Laguna).
+- **Beautiful Output:** Native Markdown formatting for AI reasoning using `marked`.
+- **Robust Parsing:** Heuristic fallback for non-JSON conversational models (like Owl Alpha).
+- **Anti-Inception Capture:** Overlay auto-hides during DOM/Screenshot capture to prevent the AI from reading its own UI.
+
+## 🚀 Planned Features
+- [ ] Add support for Anthropic Claude models.
+- [ ] Implement local, offline LLM support via Ollama.
+- [ ] Add visual bounding boxes to highlight extracted question elements on the screen.
+- [ ] Export chat logs and analysis history to Markdown files.
+- [ ] Add PDF and Word document parsing support.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ojas-sta/qalify-plus",
+  "version": "1.1.0",
+  "description": "An advanced, AI-powered educational vulnerability simulator and overlay.",
+  "main": "src/generic.js",
+  "bin": {
+    "qalify": "./src/generic.js",
+    "qalify-simulator": "./src/main.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ojas-sta/ai-quiz-assistant.git"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Ojas-sta",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@google/genai": "^2.8.0",
+    "dotenv": "^17.4.2",
+    "jimp": "^1.6.1",
+    "marked": "^18.0.5",
+    "openai": "^6.42.0",
+    "playwright": "^1.60.0",
+    "tesseract.js": "^7.0.0"
+  }
+}

package/src/ai.js

@@ -0,0 +1,155 @@
+const { GoogleGenAI, Type } = require('@google/genai');
+const { OpenAI } = require('openai');
+
+class AILayer {
+    constructor(modelName = 'gemini-2.5-flash') {
+        this.modelName = modelName;
+        this.isOpenRouter = this.modelName.includes('/');
+        
+        if (this.isOpenRouter) {
+            const key = process.env.OPENROUTER_API_KEY ? process.env.OPENROUTER_API_KEY.trim().replace(/^["']|["']$/g, '') : undefined;
+            this.openRouter = new OpenAI({
+                baseURL: "https://openrouter.ai/api/v1",
+                apiKey: key,
+                defaultHeaders: {
+                    "HTTP-Referer": "http://localhost",
+                    "X-Title": "Qalify+",
+                }
+            });
+            this.chatHistory = [];
+        } else {
+            const key = process.env.GEMINI_API_KEY ? process.env.GEMINI_API_KEY.trim().replace(/^["']|["']$/g, '') : undefined;
+            this.ai = new GoogleGenAI({ apiKey: key });
+            this.chatSession = null;
+        }
+    }
+
+    async determineAnswer(questionText, optionsText) {
+        console.log(`[AI] Analyzing question using model: ${this.modelName}...`);
+        
+        const systemPrompt = "You are an expert educational assistant taking a quiz. Apply deep reasoning and academic rigor.";
+        const userPrompt = `
+Question: ${questionText}
+Options:
+${optionsText.join('\\n')}
+
+Based on your knowledge, please select the most correct option.
+Return your answer as a structured JSON object. Use exactly these keys:
+- "selectedOption": Only the letter (A, B, C, or D) corresponding to your answer.
+- "confidenceScore": An integer from 0 to 100 representing your confidence.
+- "reasoning": A brief explanation of why this option is correct.
+`;
+
+        try {
+            let parsed = null;
+
+            if (this.isOpenRouter) {
+                // OpenRouter API
+                if (!process.env.OPENROUTER_API_KEY) throw new Error("OPENROUTER_API_KEY is missing from .env");
+
+                const response = await this.openRouter.chat.completions.create({
+                    model: this.modelName,
+                    messages: [
+                        { role: "system", content: systemPrompt },
+                        { role: "user", content: userPrompt + "\nEnsure you output ONLY valid JSON. No markdown formatting." }
+                    ]
+                });
+                
+                const resultText = response.choices[0].message.content;
+                let cleanText = resultText.replace(/```json/gi, '').replace(/```/gi, '').trim();
+                
+                try {
+                    // Try to isolate a JSON block if there's conversational text around it
+                    const jsonMatch = cleanText.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        parsed = JSON.parse(jsonMatch[0]);
+                    } else {
+                        parsed = JSON.parse(cleanText);
+                    }
+                } catch (e) {
+                    // Fallback heuristics if the model completely ignored the JSON prompt
+                    console.log(`[AI] JSON parse failed, attempting heuristic fallback on: ${cleanText.substring(0, 50)}...`);
+                    const optMatch = cleanText.match(/Option\s*([A-D])/i) || cleanText.match(/\b([A-D])\b/);
+                    if (!optMatch) throw new Error(`Model did not return JSON. Raw output: ${cleanText.substring(0, 100)}...`);
+                    
+                    parsed = {
+                        selectedOption: optMatch[1].toUpperCase(),
+                        confidenceScore: 85,
+                        reasoning: cleanText
+                    };
+                }
+
+                // Initialize chat history for OpenRouter
+                this.chatHistory = [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: `Question: ${questionText}\\nOptions: ${optionsText.join(', ')}` },
+                    { role: "assistant", content: `I chose Option ${parsed.selectedOption} with ${parsed.confidenceScore}% confidence because: ${parsed.reasoning}.` }
+                ];
+
+            } else {
+                // Google Gemini API natively
+                const responseSchema = {
+                    type: Type.OBJECT,
+                    properties: {
+                        selectedOption: { type: Type.STRING },
+                        confidenceScore: { type: Type.INTEGER },
+                        reasoning: { type: Type.STRING }
+                    },
+                    required: ["selectedOption", "confidenceScore", "reasoning"],
+                };
+
+                const response = await this.ai.models.generateContent({
+                    model: this.modelName,
+                    contents: userPrompt,
+                    config: {
+                        responseMimeType: "application/json",
+                        responseSchema: responseSchema,
+                    }
+                });
+
+                parsed = JSON.parse(response.text);
+
+                // Initialize chat session for Gemini
+                this.chatSession = this.ai.chats.create({
+                    model: this.modelName,
+                    config: {
+                        systemInstruction: `You are an AI taking a quiz. You chose Option ${parsed.selectedOption} because: ${parsed.reasoning}.`
+                    }
+                });
+            }
+
+            return parsed;
+        } catch (error) {
+            console.error("[AI] Error during reasoning:", error.message);
+            return { error: `API Error: ${error.message}` };
+        }
+    }
+
+    async chat(message) {
+        try {
+            console.log(`[AI Chat] Processing message with ${this.modelName}...`);
+            if (this.isOpenRouter) {
+                if (this.chatHistory.length === 0) return "I am not analyzing a question right now.";
+                
+                this.chatHistory.push({ role: "user", content: message });
+                const response = await this.openRouter.chat.completions.create({
+                    model: this.modelName,
+                    messages: this.chatHistory
+                });
+                
+                const reply = response.choices[0].message.content;
+                this.chatHistory.push({ role: "assistant", content: reply });
+                return reply;
+            } else {
+                if (!this.chatSession) return "I am not analyzing a question right now.";
+                const response = await this.chatSession.sendMessage({ message });
+                return response.text;
+            }
+        } catch (error) {
+            console.error("[AI Chat] Error:", error.message);
+            return `<span style="color:red">API Error: ${error.message}</span>`;
+        }
+    }
+}
+
+module.exports = AILayer;