browser-assistant 2.8.5 → 2.8.7

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
     "manifest_version": 3,
     "name": "Browser Assistant",
-    "version": "2.8.5",
+  "version": "2.8.7",
     "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.5",
+  "version": "2.8.7",
   "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.5", lifespan=lifespan)
+app = FastAPI(title="Browser Assistant API", version="2.8.7", 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,10 +1240,14 @@ 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)):
-            return False
+            return cleaned, False
 
         async def independent_solve(prompt_messages):
             if source_model is None:
@@ -1249,14 +1261,14 @@ REPAIR MODE:
             return await try_groq(prompt_messages, model=source_model, temperature=0.0)
 
         try:
-            await cross_check_text_answers(messages, cleaned, independent_solve)
+            checked = await cross_check_text_answers(messages, cleaned, independent_solve, question_text=trimmed_text)
         except Exception as exc:
             if isinstance(exc, VisionUnconfirmedError):
                 message = str(exc)
             else:
                 message = 'An independent solve was unavailable.'
             raise HTTPException(422, detail={'code': 'answer_unconfirmed', 'message': message}) from exc
-        return True
+        return checked, True
 
     # Try each Groq text model in the fallback chain
     for model_id in TEXT_MODELS:
@@ -1282,7 +1294,7 @@ REPAIR MODE:
             )
             if cleaned != "[]":
                 logger.info(f"Groq ({model_id}) returned a validated result ({len(cleaned)} characters)")
-                verified = await confirm_answers(cleaned, model_id)
+                cleaned, verified = await confirm_answers(cleaned, model_id)
                 return {"results": cleaned, "provider": f"groq ({model_id})" + (' [cross-checked]' if verified else ''),
                         "language": language, "answer_verified": verified,
                         "code_reviewed": strict_code_review and language != 'web'}
@@ -1318,7 +1330,7 @@ REPAIR MODE:
             starter_code=content.starter_code,
         )
         if cleaned != "[]":
-            verified = await confirm_answers(cleaned)
+            cleaned, verified = await confirm_answers(cleaned)
             return {
                 "results": cleaned,
                 "provider": f"ollama ({OLLAMA_MODEL})" + (' [cross-checked]' if verified else ''),
@@ -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,104 @@ 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 parse_labeled_choices(option_text):
+    lines = ('A.' + option_text).splitlines()
+    if not 2 <= len(lines) <= 26:
+        return {}
+    choices = {}
+    for index, line in enumerate(lines):
+        letter = chr(ord('A') + index)
+        option = re.fullmatch(rf'{letter}\.\s*(\S.*)', line)
+        if not option:
+            return {}
+        choices[letter] = option[1]
+    return choices
+
+
+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
+
+    matches = []
+    for letter, option in parse_labeled_choices(option_text).items():
+        value = parse_option(option)
+        if value is None:
+            return None
+        if value == expected:
+            matches.append(f'Option {letter}: {option}')
+    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)
@@ -238,7 +333,34 @@ def parse_answer_check(raw, count):
     return answers
 
 
-async def cross_check_text_answers(messages, results, complete):
+def displayed_single_choices(text):
+    question, separator, option_text = text.strip().rpartition('\nA.')
+    if not separator or not re.search(r'\n(?:Question format: )?Select one answer\.$', question, re.I):
+        return {}
+    return parse_labeled_choices(option_text)
+
+
+def bind_displayed_choice(value, choices, *, matrix_math):
+    if type(value) not in (str, int, float):
+        return None
+    answer = str(value).strip()
+
+    def key(text):
+        return normalize_checked_answer(text, matrix_math=matrix_math)
+
+    labeled = re.fullmatch(r'(?:Option\s+)?([A-Z])\s*[:.)]\s*(\S.*)', answer, re.I)
+    if labeled:
+        letter, body = labeled[1].upper(), labeled[2]
+        return letter if letter in choices and key(choices[letter]) == key(body) else None
+    matches = [letter for letter, body in choices.items() if key(body) == key(answer)]
+    letter_only = re.fullmatch(r'(?:Option\s+)?([A-Z])\s*[:.)]?', answer, re.I)
+    if letter_only and letter_only[1].upper() in choices:
+        matches.append(letter_only[1].upper())
+    unique = set(matches)
+    return unique.pop() if len(unique) == 1 else None
+
+
+async def cross_check_text_answers(messages, results, complete, *, question_text=''):
     items = json.loads(results)
     if not items or any(item.get('type') != 'mcq' for item in items):
         raise VisionUnconfirmedError('Verification requires a complete set of question answers.')
@@ -252,22 +374,42 @@ async def cross_check_text_answers(messages, results, complete):
         'If the information is incomplete or any answer is uncertain, return {"readable":false,"answers":[]}.'
     )
     check_messages = [{'role': 'system', 'content': instruction}, *messages[1:]]
+    matrix_math = matrix_question(messages)
+    choices = displayed_single_choices(question_text) if len(items) == 1 else {}
+
+    def answer_key(entries):
+        if choices:
+            return bind_displayed_choice(entries[0].get('answer'), choices, matrix_math=matrix_math)
+        keys = tuple(normalize_checked_answer(item.get('answer'), matrix_math=matrix_math) for item in entries)
+        return keys if all(keys) else None
+
+    first = answer_key(items)
+    previous = None
     for attempt in range(2):
         raw = await complete(check_messages)
         try:
             verified = parse_answer_check(raw, len(items))
+            current = answer_key(verified)
+        except ValueError:
+            current = None
+        if current is not None and (current == first or current == previous):
+            if choices:
+                if current != first:
+                    items[0].pop('reasoning', None)
+                items[0]['answer'] = f'Option {current}: {choices[current]}'
+                return json.dumps(items, ensure_ascii=False)
+            return results
+        if not choices and current is not None:
             break
-        except ValueError as exc:
-            if attempt:
-                raise VisionUnconfirmedError('The independent solve could not verify every answer after retrying.') from exc
+        if not attempt:
+            previous = current
             check_messages = [*check_messages, {
                 'role': 'user',
                 'content': 'Solve again using the original question and options. Return the full verification JSON with the required ids.',
             }]
-    matrix_math = matrix_question(messages)
-    first = [normalize_checked_answer(item['answer'], matrix_math=matrix_math) for item in items]
-    if not all(first) or first != [normalize_checked_answer(item['answer'], matrix_math=matrix_math) for item in verified]:
-        raise VisionUnconfirmedError('The two solves disagreed on at least one answer.')
+    if current is None and previous is None:
+        raise VisionUnconfirmedError('The independent solve could not verify every answer after retrying.')
+    raise VisionUnconfirmedError('The independent solves could not agree on the displayed answer.')
 
 
 async def cross_check_visual_answers(messages, results, model, complete, comparison=None, *, require_agreement=False):