V9.0.5: Prevent SSE Disconnects - Non-Blocking SymPy Validator & Timeout Optimization

domain/math_validator.py

@@ -1,10 +1,11 @@
 # domain/math_validator.py — V1.1 (STABLE REGEX POLYGRAPH)
 import re
 import logging
-import multiprocessing
+import re
+import logging
 import time
 import asyncio
-from typing import Tuple, List, Optional
+from typing import Tuple, List, Optional, Any
 import sympy
 from sympy.parsing.sympy_parser import parse_expr
 from utils.math_utils import aggressive_sympy_sanitizer
@@ -95,75 +96,6 @@ def _is_plaintext(expr_str: str) -> bool:
 class MathPolygraph:
     TIMEOUT_SECONDS = 3
 
-    @staticmethod
-    def _sympify_worker(expr_str: str, queue: multiprocessing.Queue):
-        """
-        V280.0: Security Hardened Worker.
-        1. Character Whitelist: Only allow safe mathematical characters.
-        2. parse_expr(evaluate=False): Prevent RCE and immediate evaluation.
-        """
-        try:
-            # V317.8: Suppress SymPy Deprecation Warnings (e.g. non-Expr in Pow)
-            import warnings
-            from sympy.utilities.exceptions import SymPyDeprecationWarning
-            warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
-
-            # RCE Prevention: Extreme character whitelist before parsing
-            # V280.0 FIX: Added ! for factorials and ensured strict match.
-            safe_pattern = r'^[a-zA-Z0-9\s\+\-\*\/\^\(\)\.\,\!\%\=]+$'
-            if not re.match(safe_pattern, expr_str):
-                queue.put(False)
-                return
-
-            # Security: evaluate=False stops automatic eval() of passed strings.
-            res = parse_expr(expr_str, evaluate=False)
-            
-            # V280.0 FIX: Catch arithmetic errors like 1/0. 
-            # In SymPy, 1/0 evaluates to 'zoo' (ComplexInfinity).
-            if res is not None:
-                # evaluate the expression
-                evaluated = res.doit()
-                # If the result is infinite (zoo, oo, -oo) or NaN, treat as error
-                # We check is_finite directly.
-                if hasattr(evaluated, 'is_finite') and evaluated.is_finite is False:
-                    raise ZeroDivisionError("Infinite or undefined result")
-                if hasattr(evaluated, 'is_nan') and evaluated.is_nan:
-                    raise ValueError("NaN result")
-                
-            queue.put(True)
-        except (ZeroDivisionError, TypeError, ValueError, Exception) as e:
-            queue.put(False)
-
-    @staticmethod
-    def _sympify_with_timeout(expr_str: str) -> bool:
-        """Helper to run parsing in a separate process to enforce timeout."""
-        if not expr_str or not expr_str.strip():
-            return True
-            
-        # Strip characters that might survive _latex_to_sympy_str but fail whitelist
-        s = expr_str.replace('\\', '').replace('_', '').replace('{', '(').replace('}', ')')
-        
-        queue = multiprocessing.Queue()
-        process = multiprocessing.Process(target=MathPolygraph._sympify_worker, args=(s, queue))
-        try:
-            process.start()
-            # Windows needs a generous timeout for cold process start + SymPy import.
-            # 10 seconds is safe for verification/testing.
-            process.join(timeout=10)
-            if process.is_alive():
-                process.terminate()
-                process.join()
-                with open('debug_math.val', 'a', encoding='utf-8') as f:
-                    f.write(f"[{time.time()}] TIMEOUT on '{s}'\n")
-                return None # TIMEOUT
-            if not queue.empty():
-                return queue.get()
-            return False
-        except Exception:
-            if process.is_alive():
-                process.terminate()
-            return False
-
     @staticmethod
     async def _validate_single(text: str, step_id) -> Tuple[bool, str]:
         """
@@ -207,6 +139,20 @@ class MathPolygraph:
                 
         return True, ""
 
+    @staticmethod
+    async def _run_safe_math_op(func, *args, timeout_sec: float = 0.3) -> Any:
+        """
+        V9.0.5: Executes a CPU-bound SymPy operation in a separate thread with a strict timeout.
+        Returns the result of the function, or raises TimeoutError/Exception.
+        """
+        try:
+            return await asyncio.wait_for(
+                asyncio.to_thread(func, *args),
+                timeout=timeout_sec
+            )
+        except asyncio.TimeoutError:
+            raise asyncio.TimeoutError("SymPy operation timed out")
+
     @staticmethod
     async def _check_segment(raw_segment: str, step_id) -> Tuple[bool, str]:
         """Internal helper to validate a single extracted math segment."""
@@ -222,18 +168,34 @@ class MathPolygraph:
                 continue
                 
             try:
-                # Run with timeout to prevent ReDoS or complex simplification hangs
-                status = await asyncio.to_thread(MathPolygraph._sympify_with_timeout, sympy_str)
+                # V9.0.5: Wrap CPU-bound sympify/parsing in a non-blocking thread with 300ms timeout
+                # We bypass the slow multiprocessing approach for SSE safety.
+                def parse_and_eval(s):
+                    # Character Whitelist (from legacy _sympify_worker)
+                    safe_pattern = r'^[a-zA-Z0-9\s\+\-\*\/\^\(\)\.\,\!\%\=]+$'
+                    if not re.match(safe_pattern, s):
+                        return False
+                    res = parse_expr(s, evaluate=False)
+                    if res is not None:
+                        evaluated = res.doit()
+                        if hasattr(evaluated, 'is_finite') and evaluated.is_finite is False:
+                            return False
+                        if hasattr(evaluated, 'is_nan') and evaluated.is_nan:
+                            return False
+                    return True
+
+                status = await MathPolygraph._run_safe_math_op(parse_and_eval, sympy_str)
+                
                 if status is False:
-                    # Provide clearer error context
-                    logger.warning(f"[V9.0.1] SymPy Parse Error on part '{part}' (from segment '{raw_segment}')")
-                    return False, f"SYMPY_PARSE_ERROR:step_{step_id}"
-                elif status is None:
-                    # Timeout is treated as a soft warning for now
-                    logger.warning(f"[V280.0] SymPy timeout on segment: {part}")
+                    logger.warning(f"🛡️ [SOFT FAIL] SymPy Parse Error on part '{part}'. Bypassing validator.")
+                    return True, "" # Soft Fail: allow stream to continue
+                    
+            except asyncio.TimeoutError:
+                logger.warning(f"🛡️ [SOFT FAIL] SymPy TIMEOUT (300ms) on part '{part}'. Bypassing validator.")
+                return True, "" # Soft Fail: allow stream to continue
             except Exception as e:
-                logger.error(f"[V280.0] Unexpected validation crash: {e}")
-                return False, f"SYMPY_CRASH:step_{step_id}"
+                logger.warning(f"🛡️ [SOFT FAIL] Unexpected validation crash: {e} for part '{part}'. Bypassing.")
+                return True, "" # Soft Fail: allow stream to continue
 
         return True, ""
 
@@ -267,21 +229,20 @@ class MathPolygraph:
                 return False, reason
         return True, ""
     @staticmethod
-    def are_equivalent(latex1: str, latex2: str) -> bool:
+    async def are_equivalent(latex1: str, latex2: str) -> bool:
         """
-        V1.2: Checks if two LaTeX expressions are mathematically equivalent.
+        V9.0.5: Checks if two LaTeX expressions are mathematically equivalent (Non-Blocking).
         Supports expressions and equations (by converting to 'expr = 0').
         """
         try:
-            # V280.0: Handle Equations in Equivalence Check
-            # If both contain '=', split and compare parts.
-            # Only recurse once!
+            # 1. Handle Equations in Equivalence Check
             if '=' in latex1 and '=' in latex2 and latex1.count('=') == 1 and latex2.count('=') == 1:
                 parts1 = [p.strip() for p in latex1.split('=') if p.strip()]
                 parts2 = [p.strip() for p in latex2.split('=') if p.strip()]
                 if len(parts1) == 2 and len(parts2) == 2:
-                    return MathPolygraph.are_equivalent(parts1[0], parts2[0]) and \
-                           MathPolygraph.are_equivalent(parts1[1], parts2[1])
+                    res1 = await MathPolygraph.are_equivalent(parts1[0], parts2[0])
+                    res2 = await MathPolygraph.are_equivalent(parts1[1], parts2[1])
+                    return res1 and res2
 
             s1_raw = _latex_to_sympy_str(latex1)
             s2_raw = _latex_to_sympy_str(latex2)
@@ -300,19 +261,25 @@ class MathPolygraph:
             if not (is_safe(s1_raw) and is_safe(s2_raw)):
                 return latex1.strip() == latex2.strip()
 
-            expr1 = parse_expr(s1_raw, evaluate=False)
-            expr2 = parse_expr(s2_raw, evaluate=False)
-            
-            # "Variable Trap": Basic structural equivalence if variables are involved
-            if len(expr1.free_symbols) > 0 or len(expr2.free_symbols) > 0:
-                return sympy.simplify(expr1 - expr2) == 0
+            # V9.0.5: Wrap CPU-bound SymPy simplify in a thread with timeout
+            def calc_equivalence(str1, str2):
+                expr1 = parse_expr(str1, evaluate=False)
+                expr2 = parse_expr(str2, evaluate=False)
+                # "Variable Trap": Basic structural equivalence if variables are involved
+                if len(expr1.free_symbols) > 0 or len(expr2.free_symbols) > 0:
+                    return sympy.simplify(expr1 - expr2) == 0
+                # Numerical Identity check
+                diff = sympy.simplify(expr1 - expr2)
+                return diff == 0
+
+            return await MathPolygraph._run_safe_math_op(calc_equivalence, s1_raw, s2_raw)
 
-            # Numerical Identity check: simplify(LHS - RHS) == 0
-            diff = sympy.simplify(expr1 - expr2)
-            return diff == 0
+        except asyncio.TimeoutError:
+            logger.warning(f"🛡️ [SOFT FAIL] Equivalence check TIMEOUT (300ms) for {latex1} vs {latex2}")
+            return True # Soft Fail: Assume equivalent if we can't prove otherwise in time
         except Exception as e:
-            logger.warning(f"[POLYGRAPH] Equivalence check failed: {e}")
-            return False 
+            logger.warning(f"🛡️ [SOFT FAIL] Equivalence check failed: {e}")
+            return True # Soft Fail: Assume equivalent on error
 
     @staticmethod
     async def verify_algebraic_consistency(steps: List[dict], topic: str = "GENERAL") -> Tuple[bool, str]:
@@ -340,7 +307,7 @@ class MathPolygraph:
             s2 = math_steps[i+1]['math']
             
             # Simple heuristic: Only verify if they look like comparable equations/expressions
-            if not MathPolygraph.are_equivalent(s1, s2):
+            if not await MathPolygraph.are_equivalent(s1, s2):
                 logger.info(f"[POLYGRAPH] Consistency warning between {s1} and {s2}")
                 # We return False only if we are VERY sure.
                 # For now, we'll return False to trigger self-correction as requested.

orchestrator.py

@@ -2306,7 +2306,7 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
                 fast_result, _, _ = validate_and_fix_solution(fast_result)
                 # Quick Polygraph check
                 _poly_steps = collect_all_steps(fast_result)
-                _poly_ok, _ = MathPolygraph.validate_step_sequence(_poly_steps, topic=str(strategy.value))
+                _poly_ok, _ = await MathPolygraph.validate_step_sequence(_poly_steps, topic=str(strategy.value))
                 
                 if _poly_ok:
                     yield BuddyEvent(