browser-assistant 2.8.4 → 2.8.6

package/extension/automation-policy.js

@@ -379,6 +379,25 @@
             const unique = [...new Set(candidates)];
             return unique.length === 1 ? unique[0] : null;
         },
+        getPracticeSkip(doc, question) {
+            const anchor = question.form || question.container;
+            if (!anchor)
+                return null;
+            const skips = [...doc.querySelectorAll('button,[role="button"]')].filter(button => button.isConnected && button.getClientRects().length && !button.disabled
+                && button.getAttribute('aria-disabled') !== 'true' && !button.closest('#assistant-root')
+                && /^skip(?: question)?$/i.test((button.innerText || button.textContent || button.getAttribute('aria-label') || '').trim()));
+            if (skips.length !== 1)
+                return null;
+            for (let scope = anchor; scope && scope !== doc.body; scope = scope.parentElement) {
+                if (!scope.contains(skips[0]))
+                    continue;
+                const submits = [...scope.querySelectorAll('button,[role="button"],input[type="submit"]')].filter(button => button.getClientRects().length && !button.closest('#assistant-root')
+                    && /^submit(?: answer)?$/i.test((button.innerText || button.textContent || button.value || button.getAttribute('aria-label') || '').trim()));
+                if (submits.length === 1)
+                    return skips[0];
+            }
+            return null;
+        },
         getBlockingReason(doc) {
             const expired = [...doc.querySelectorAll('p,span,div,h1,h2,h3,h4')].some(node => node.getClientRects().length && !node.closest('#assistant-root') && !node.children.length
                 && /^time['’]s up!\s*you cannot attempt this assessment now\.?$/i.test((node.innerText || node.textContent || '').trim()));

package/extension/content.js

@@ -415,6 +415,7 @@
         const currentQuestion = automation.batch?.title || (automation.running && automation.codingQuestionText)
             || (authorized ? getAuthorizedQuestion(context)?.text : '');
         const pageName = authorized ? context.target.id : window.location.hostname;
+        const deferred = automation.deferredQuestions?.size ?? 0;
         if (status) {
             status.textContent = authorized
                 ? `Build ${extensionVersion} · ${context.target.id}: ${automation.state} · Completed: ${automation.completed}${automation.error ? ` · ${automation.error}` : ''}`
@@ -431,14 +432,15 @@
         if (question)
             question.textContent = currentQuestion || '—';
         if (progress)
-            progress.textContent = `${automation.completed} / —`;
+            progress.textContent = deferred ? `${automation.completed} completed · ${deferred} deferred` : `${automation.completed} / —`;
         if (latest) {
+            const reviewing = ['WAITING_FOR_REVIEW', 'DEFERRING_QUESTION', 'REVIEW_NEEDED'].includes(automation.state);
             latest.textContent = automation.error
-                ? `⚠ ${automation.error}`
+                ? reviewing ? automation.error : `⚠ ${automation.error}`
                 : authorized
                     ? `Current status: ${automation.state.replace(/_/g, ' ').toLowerCase()}.`
                     : 'Automation is available only on an authorized QA page.';
-            latest.classList.toggle('has-error', Boolean(automation.error));
+            latest.classList.toggle('has-error', Boolean(automation.error) && !reviewing);
         }
         if (start)
             start.disabled = !authorized || automation.running;
@@ -477,6 +479,8 @@
         automation.paused = false;
         automation.pendingNavigation = false;
         automation.state = reason;
+        if (reason === 'REVIEW_NEEDED')
+            automation.error = 'Review deferred questions on the portal.';
         updateAutomationUI();
     }
     async function waitWhilePaused(runId) {
@@ -1178,6 +1182,73 @@
                 stopAutomation('STOPPED');
         }
     }
+    async function continueAfterUnverifiedQuestion(question, runId, reason, allowSkip = true) {
+        if (!(await waitWhilePaused(runId)))
+            return false;
+        const initial = getAutomationContext();
+        const adapter = getAutomationAdapter(initial);
+        if (!adapter || initial.target.id !== automation.targetId) {
+            stopAutomation('UNAUTHORIZED');
+            return false;
+        }
+        const fresh = getAuthorizedQuestion(initial);
+        const sameQuestion = fresh?.signature === question.signature && hasSameQuestionOptions(question, fresh);
+        const practice = initial.target.id === 'ccbp-learning-practice'
+            && /^\/(?:default-question|primitive-coding(?:-review)?)\/practice\//.test(location.pathname);
+        const hasDraft = fresh?.input?.value?.trim() || fresh?.options.some(option => option.isSelected?.() || option.input?.checked);
+        if (allowSkip && practice && sameQuestion && !hasDraft && question.type !== 'ordering'
+            && !adapter.isSaving?.(document) && !adapter.getSubmittedAdvance?.(document)
+            && automationPolicy.canExecute('click', initial) && automationPolicy.canExecute('validate', initial)) {
+            const skip = adapter.getPracticeSkip?.(document, fresh);
+            if (skip) {
+                automation.state = 'DEFERRING_QUESTION';
+                automation.error = reason;
+                automation.pendingNavigation = true;
+                updateAutomationUI();
+                skip.click();
+                const transition = await waitForPracticeTransition(question.signature, runId);
+                if (!automation.running || automation.runId !== runId)
+                    return false;
+                automation.pendingNavigation = false;
+                if (transition === 'next' || transition === 'complete') {
+                    automation.deferredQuestions.add(question.signature);
+                    automation.error = '';
+                    return true;
+                }
+            }
+        }
+        automation.state = 'WAITING_FOR_REVIEW';
+        automation.error = `${reason} Use the page controls to review and move to the next question. Automation will continue here.`;
+        updateAutomationUI();
+        while (await waitWhilePaused(runId)) {
+            if (automation.state !== 'WAITING_FOR_REVIEW') {
+                automation.state = 'WAITING_FOR_REVIEW';
+                updateAutomationUI();
+            }
+            const context = getAutomationContext();
+            const currentAdapter = getAutomationAdapter(context);
+            if (context.mode !== 'FULL' || context.target.id !== initial.target.id || currentAdapter?.id !== adapter.id) {
+                stopAutomation('UNAUTHORIZED');
+                return false;
+            }
+            const blocked = currentAdapter.getBlockingReason?.(document);
+            if (blocked) {
+                automation.error = blocked;
+                stopAutomation('PAUSED');
+                return false;
+            }
+            if (!currentAdapter.isSaving?.(document)) {
+                const current = getAuthorizedQuestion(context);
+                if (currentAdapter.getSubmittedAdvance?.(document) || currentAdapter.isComplete(document)
+                    || (current && current.signature !== question.signature && !hasSameQuestionOptions(question, current))) {
+                    automation.error = '';
+                    return true;
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 250));
+        }
+        return false;
+    }
     async function startPracticeAutomation() {
         if (window.BrowserAssistantJournal?.matches()) {
             await window.BrowserAssistantJournal.start();
@@ -1230,6 +1301,7 @@
         automation.paused = false;
         automation.error = '';
         automation.completed = 0;
+        automation.deferredQuestions = new Set();
         automation.targetId = initialContext.target.id;
         automation.pendingNavigation = false;
         automation.currentSignature = null;
@@ -1286,10 +1358,12 @@
                 const transition = await waitForPracticeTransition(previousSignature, runId);
                 if (!automation.running || automation.runId !== runId)
                     break;
-                if (transition === 'next' || transition === 'complete')
+                if (transition === 'next' || transition === 'complete') {
                     automation.completed += 1;
+                    automation.deferredQuestions.delete(previousSignature);
+                }
                 if (transition === 'complete') {
-                    stopAutomation('COMPLETED');
+                    stopAutomation(automation.deferredQuestions.size ? 'REVIEW_NEEDED' : 'COMPLETED');
                     break;
                 }
                 if (transition !== 'next') {
@@ -1300,6 +1374,10 @@
                 continue;
             }
             if (currentAdapter.isComplete(document)) {
+                if (automation.deferredQuestions.size) {
+                    stopAutomation('REVIEW_NEEDED');
+                    break;
+                }
                 const nextPractice = currentAdapter.getNextPractice?.(document);
                 if (!nextPractice) {
                     stopAutomation('COMPLETED');
@@ -1341,6 +1419,12 @@
                 await runCodingAutomation(question, runId);
                 break;
             }
+            if (automation.deferredQuestions.has(question.signature)) {
+                automation.currentSignature = question.signature;
+                if (await continueAfterUnverifiedQuestion(question, runId, 'This question was deferred earlier.', false))
+                    continue;
+                break;
+            }
             if (automation.processed.has(question.signature)) {
                 automation.error = 'Repeated question detected.';
                 stopAutomation('PAUSED');
@@ -1403,7 +1487,12 @@
                 if (!automation.running || automation.runId !== runId)
                     break;
                 automation.error = error.message || 'Local AI server unavailable.';
-                stopAutomation(['answer_unconfirmed', 'vision_unconfirmed'].includes(error.code) ? 'PAUSED' : 'ERROR');
+                if (['answer_unconfirmed', 'vision_unconfirmed'].includes(error.code)) {
+                    if (await continueAfterUnverifiedQuestion(question, runId, automation.error))
+                        continue;
+                }
+                else
+                    stopAutomation('ERROR');
                 break;
             }
             if (!automation.running || automation.runId !== runId || !response)
@@ -1474,6 +1563,11 @@
             // transient code-block markup.
             if (!answerIndexes.length || !current || !hasSameQuestionOptions(question, current)) {
                 automation.error = !answerIndexes.length ? 'The verified answer did not match the displayed options exactly.' : !current ? 'Question controls disappeared while solving.' : 'Question text or options changed while solving. Please retry.';
+                if (!answerIndexes.length && current?.signature === question.signature && hasSameQuestionOptions(question, current)) {
+                    if (await continueAfterUnverifiedQuestion(question, runId, automation.error))
+                        continue;
+                    break;
+                }
                 stopAutomation('PAUSED');
                 break;
             }
@@ -1590,7 +1684,7 @@
             }
             if (transition === 'complete') {
                 automation.completed += 1;
-                stopAutomation('COMPLETED');
+                stopAutomation(automation.deferredQuestions.size ? 'REVIEW_NEEDED' : 'COMPLETED');
                 break;
             }
             if (transition !== 'next') {

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
     "manifest_version": 3,
     "name": "Browser Assistant",
-    "version": "2.8.4",
+  "version": "2.8.6",
     "description": "Scans webpages for MCQs and coding problems. Powered by Groq (cloud) and Ollama (local fallback).",
     "permissions": [
         "activeTab",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-assistant",
-  "version": "2.8.4",
+  "version": "2.8.6",
   "description": "Chrome extension and local Python backend for exploring webpage questions and coding exercises",
   "license": "MIT",
   "repository": {

package/server/main.py

@@ -24,7 +24,8 @@ from fastapi.exception_handlers import http_exception_handler
 from local_security import install_local_guards, redact, sanitize_data
 from vision_images import (compress_image_base64, unique_image_blocks, collect_image_evidence,
                            cross_check_visual_answers, relative_percentage_question, RELATIVE_PERCENTAGE_INSTRUCTION,
-                           answer_permutation, cross_check_text_answers, VisionRateLimitError, VisionUnconfirmedError)
+                           answer_permutation, cross_check_text_answers, solve_matrix_choice,
+                           VisionRateLimitError, VisionUnconfirmedError)
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
 logger = logging.getLogger("browser-assistant")
@@ -190,7 +191,7 @@ async def lifespan(_app: FastAPI):
             client.close()
 
 
-app = FastAPI(title="Browser Assistant API", version="2.8.4", lifespan=lifespan)
+app = FastAPI(title="Browser Assistant API", version="2.8.6", lifespan=lifespan)
 install_local_guards(app)
 
 @app.exception_handler(HTTPException)
@@ -1190,6 +1191,13 @@ async def review_and_correct_code(
 
 # ── Routes ────────────────────────────────────────────────────────────────────
 
+def calculated_matrix_result(text, language):
+    item = solve_matrix_choice(text)
+    if item is not None:
+        return {"results": json.dumps([item], ensure_ascii=False), "provider": "local matrix calculation [verified]",
+                "language": language, "answer_verified": True, "code_reviewed": False}
+
+
 @app.post("/solve")
 async def solve_questions(content: PageContent):
     # Trim oversized page text to stay within token limits
@@ -1232,6 +1240,10 @@ REPAIR MODE:
     )
     strict_code_review = require_code and (content.review_before_submit or not FAST_CODE_MODE or STRICT_REPAIR_REVIEW)
     verify_answers = not require_code and (content.verify_answer or not FAST_SCAN_MODE)
+    if not require_code and content.practice_type in {'auto', 'mcq', 'math', 'aptitude'}:
+        matrix_result = calculated_matrix_result(trimmed_text, language)
+        if matrix_result is not None:
+            return matrix_result
 
     async def confirm_answers(cleaned, source_model=None):
         if not verify_answers or not any(item['type'] == 'mcq' for item in json.loads(cleaned)):
@@ -1395,6 +1407,11 @@ async def _solve_vision(content: VisionContent):
             compressed.append(await asyncio.to_thread(compress_image_base64, image, max_dim=2400, quality=95))
         except ValueError as exc:
             raise HTTPException(422, f'Image {index}: {exc}') from exc
+    is_code_scan = content.practice_type == "code" or (content.practice_type == "auto" and bool(content.language))
+    if not is_code_scan and content.practice_type in {'auto', 'mcq', 'math', 'aptitude'}:
+        matrix_result = calculated_matrix_result(content.text, content.language or CODE_DEFAULT_LANGUAGE)
+        if matrix_result is not None:
+            return matrix_result
     image_blocks, image_positions = unique_image_blocks(compressed)
 
     clients = tuple(_groq_clients)
@@ -1406,7 +1423,6 @@ async def _solve_vision(content: VisionContent):
     loop = asyncio.get_running_loop()
     errors = []
     rate_limit_resets = []
-    is_code_scan = content.practice_type == "code" or (content.practice_type == "auto" and bool(content.language))
     comparison = None if is_code_scan else relative_percentage_question(content.text)
     unconfirmed = False
     vision_token_limit = 4096 if is_code_scan else VISION_MAX_TOKENS

package/server/vision_images.py

@@ -170,9 +170,13 @@ def answer_permutation(value):
 MATRIX_SYNTAX = re.compile(r'\\begin\{(?:[bpBvV]?matrix|smallmatrix)\}')
 
 
-def numeric_matrix_key(value):
+def unwrap_math(value):
     text = re.sub(r'^\${1,2}|\${1,2}$', '', value.strip())
-    text = re.sub(r'^\\[\[(]|\\[\])]$', '', text).strip().replace('−', '-')
+    return re.sub(r'^\\[\[(]|\\[\])]$', '', text).strip().replace('−', '-')
+
+
+def matrix_cells(value):
+    text = unwrap_math(value)
     latex = re.fullmatch(r'\\begin\{([bpBvV]?matrix|smallmatrix)\}(.*?)\\end\{\1\}', text, re.S)
     array = re.fullmatch(r'\[\s*(\[[^\[\]]+\](?:\s*,\s*\[[^\[\]]+\])*)\s*\]', text)
     if latex:
@@ -181,13 +185,97 @@ def numeric_matrix_key(value):
         rows = [row.split(',') for row in re.findall(r'\[([^\[\]]+)\]', array[1])]
     else:
         return None
-    cells = [[cell.strip() for cell in row] for row in rows]
+    return [[cell.strip() for cell in row] for row in rows]
+
+
+def numeric_matrix_key(value):
+    cells = matrix_cells(value)
     if cells and all(len(row) == len(cells[0]) and all(
             re.fullmatch(r'[+-]?(?:\d+(?:\.\d+)?|\.\d+)', cell, re.ASCII) for cell in row) for row in cells):
         return json.dumps(cells, separators=(',', ':'))
     return None
 
 
+def matrix_2x2(value):
+    rows = matrix_cells(value)
+    if not rows or len(rows) != 2 or any(len(row) != 2 for row in rows):
+        return None
+    entries = []
+    for cell in (cell for row in rows for cell in row):
+        cell = re.sub(r'^([+-]?)\\(?:[dt]?frac)\{([+-]?\d{1,15})\}\{(\d{1,15})\}$',
+                      r'\1\2/\3', cell)
+        if not re.fullmatch(rf'(?:{DECIMAL_VALUE}|[+-]?\d{{1,15}}/\d{{1,15}})', cell):
+            return None
+        try:
+            entries.append(Fraction(cell))
+        except ZeroDivisionError:
+            return None
+    return tuple(entries)
+
+
+def solve_matrix_choice(text):
+    """Calculate a self-contained matrix question with one matching displayed choice."""
+    question, separator, option_text = text.strip().rpartition('\nA.')
+    if not separator:
+        return None
+    question = re.sub(r'\n(?:Question format: )?Select one answer\.$', '', question, flags=re.I)
+    question = re.sub(r'^\d+\s*of\s*\d+\s*questions?\s*\d+\s*marks?\s*', '', question, flags=re.I)
+    # Math delimiters and layout whitespace do not carry meaning in these prompts.
+    prompt = re.sub(r'\s+', ' ', question.replace('$', '')).strip()
+    inverse = re.fullmatch(
+        r'For ([A-Z])\s*=\s*(.+?),\s*what is \1\^(?:\{-1\}|-1)'
+        r'(?: computed using the adjugate method)?\?', prompt,
+    )
+    product = re.fullmatch(
+        r'For matrices ([A-Z]) with shape \(\s*([a-z])\s*,\s*([a-z])\s*\) and '
+        r'([A-Z]) with shape \(\s*([a-z])\s*,\s*([a-z])\s*\),\s*'
+        r'which condition must hold for the product (\1\4|\4\1) to be defined\?', prompt,
+    )
+    if inverse:
+        entries = matrix_2x2(inverse[2])
+        if entries is None:
+            return None
+        a, b, c, d = entries
+        determinant = a * d - b * c
+        if not determinant:
+            return None
+        expected = (d / determinant, -b / determinant, -c / determinant, a / determinant)
+        parse_option = matrix_2x2
+        reasoning = f'The determinant is ({a})({d}) − ({b})({c}) = {determinant}. Divide the adjugate by the determinant.'
+    elif product:
+        first, first_rows, first_cols, second, second_rows, second_cols, order = product.groups()
+        if first == second or len({first_rows, first_cols, second_rows, second_cols}) != 4:
+            return None
+        left_cols, right_rows = (first_cols, second_rows) if order == first + second else (second_cols, first_rows)
+        expected = frozenset((left_cols, right_rows))
+
+        def parse_option(value):
+            equation = re.fullmatch(r'([a-z])\s*=\s*([a-z])', unwrap_math(value))
+            return frozenset(equation.groups()) if equation else None
+
+        reasoning = f'The left matrix has {left_cols} columns and the right matrix has {right_rows} rows. These must be equal.'
+    else:
+        return None
+
+    lines = ('A.' + option_text).splitlines()
+    if not 2 <= len(lines) <= 26:
+        return None
+    matches = []
+    for index, line in enumerate(lines):
+        letter = chr(ord('A') + index)
+        option = re.fullmatch(rf'{letter}\.\s*(\S.*)', line)
+        if not option:
+            return None
+        value = parse_option(option[1])
+        if value is None:
+            return None
+        if value == expected:
+            matches.append(f'Option {letter}: {option[1]}')
+    if len(matches) != 1:
+        return None
+    return {'type': 'mcq', 'question': question, 'answer': matches[0], 'reasoning': reasoning}
+
+
 def normalize_checked_answer(value, *, matrix_math=False):
     if answer_permutation(value):
         return json.dumps(value)