First

api.py

@@ -21,8 +21,12 @@ from selenium.webdriver.support import expected_conditions as EC
 from selenium.common.exceptions import TimeoutException, NoSuchElementException, StaleElementReferenceException
 import random
 import pyautogui
+# Import the fully updated streaming module
 from streaming import StreamProcessor, create_streaming_response, StreamConfig, StreamingResponseGenerator
 import base64
+import mss
+import mss.tools
+from PIL import Image
 
 # Virtual display setup for Linux headless environments
 import platform
@@ -36,6 +40,11 @@ if platform.system() == 'Linux':
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("lmarena.log")
+    ],
+    force=True
 )
 logger = logging.getLogger(__name__)
 
@@ -68,10 +77,14 @@ class DriverNotAvailableError(LmArenaError): pass
 class Message(BaseModel):
     role: str
     content: Union[str, List[Dict[str, str]]]
+
 class ChatCompletionRequest(BaseModel):
     messages: List[Message]
     model: str
     stream: Optional[bool] = False
+    stream_raw_html: Optional[bool] = False
+    convert_html_to_markdown: Optional[bool] = True
+
 class Usage(BaseModel):
     prompt_tokens: int; completion_tokens: int; total_tokens: int
 class Choice(BaseModel):
@@ -94,7 +107,6 @@ class ModelListResponse(BaseModel):
     object: str = "list"
     data: List[ModelInfo]
 
-
 class DriverManager:
     def __init__(self):
         logger.info("DriverManager instance created.")
@@ -107,7 +119,7 @@ class DriverManager:
                 logger.info("Gemini client initialized successfully.")
             except Exception as e:
                 logger.error(f"Failed to initialize Gemini client: {e}", exc_info=True)
-                self._genai_client = None # Ensure it's None if init fails
+                self._genai_client = None
         else:
             logger.info("GEMINI_API_KEY not set, Gemini client will not be used for captcha.")
 
@@ -116,10 +128,8 @@ class DriverManager:
             if self._driver is not None:
                 logger.warning("Driver initialization called but driver already exists.")
                 return
-
             loop = asyncio.get_event_loop()
             logger.info("Initializing Selenium driver...")
-
             def _sync_initialize_driver_logic():
                 logger.info("Executing synchronous driver initialization and enhanced readiness check.")
                 temp_driver = None
@@ -128,47 +138,33 @@ class DriverManager:
                     logger.info("Driver instantiated. Opening URL...")
                     temp_driver.open(config.lmarena_url)
                     logger.info(f"URL '{config.lmarena_url}' opened.")
-
-                    # --- STAGE 1 CAPTCHA HANDLING (Cloudflare / Pre-site) ---
                     logger.info("Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...")
                     temp_driver.uc_gui_click_captcha()
                     logger.info("uc_gui_click_captcha() completed. Main site should be loading now.")
-                    # --- END STAGE 1 ---
-
-                    # ---- STAGE 2 CAPTCHA HANDLING (On-site "Verify Human" popup) ----
                     self._perform_sync_captcha_checks(temp_driver)
-                    # ---- END STAGE 2 ----
                     return temp_driver
                 except Exception as e:
                     logger.error(f"Synchronous driver initialization failed: {e}", exc_info=True)
                     if temp_driver: temp_driver.quit()
                     raise LmArenaError(f"Failed to initialize driver: {e}") from e
-
             try:
                 self._driver = await loop.run_in_executor(None, _sync_initialize_driver_logic)
                 logger.info("Selenium driver initialization process completed successfully.")
             except Exception as e:
                 logger.error(f"Asynchronous driver initialization failed: {e}", exc_info=True)
-                if self._driver: # Check if driver was partially assigned
-                    try: 
-                        # Ensure self._driver is used if it was assigned before error
+                if self._driver:
+                    try:
                         driver_to_quit = self._driver
-                        self._driver = None # Clear it before attempting quit
+                        self._driver = None
                         await loop.run_in_executor(None, driver_to_quit.quit)
-                    except Exception as quit_e: 
+                    except Exception as quit_e:
                         logger.error(f"Failed to quit driver after initialization error: {quit_e}")
-                else: # If self._driver was never assigned (e.g. error in Driver() call itself)
-                    logger.debug("No driver instance to quit after initialization error.")
-                
                 if isinstance(e, LmArenaError):
                     raise
                 raise LmArenaError(f"Failed to initialize driver: {e}") from e
 
     def _human_like_reload(self, driver: Driver):
-        """Human-like page reload with F5/FN+F5 variation"""
         logger.info("Performing human-like page reload")
-        
-        # Randomly choose between F5 and FN+F5
         if random.random() > 0.5:
             logger.info("Using F5 key")
             pyautogui.press('f5')
@@ -179,165 +175,69 @@ class DriverManager:
             pyautogui.press('f5')
             time.sleep(0.3)
             pyautogui.keyUp('ctrl')
-        
-        # Add random delay to simulate human behavior
         sleep_time = random.uniform(0.5, 2.0)
         time.sleep(sleep_time)
         logger.info(f"Page reloaded after {sleep_time:.2f}s delay")
     
-    def _random_mouse_movement(self, driver: Driver):
-        logger.info("Performing natural random mouse movement with pyautogui")
-        try:
-            import pyautogui
-            import random
-            import math
-            import time
-            
-            # Get screen dimensions
-            screen_width, screen_height = pyautogui.size()
-            center_x = screen_width // 2
-            center_y = screen_height // 2
-            
-            # Generate random movement pattern (combination of arcs and lines)
-            patterns = [
-                # Small circles around center
-                lambda: [(int(center_x + 50 * math.cos(angle)), int(center_y + 50 * math.sin(angle))) for angle in [2 * math.pi * i / 8 for i in range(8)]],
-                
-                # Diagonal sweeps
-                lambda: [(100, 100), (screen_width-100, screen_height-100), (100, screen_height-100), (screen_width-100, 100)],
-                
-                # Random walk
-                lambda: [(random.randint(100, screen_width-100), random.randint(100, screen_height-100)) for _ in range(5)]
-            ]
-            
-            # Select and execute random pattern
-            pattern = random.choice(patterns)()
-            total_points = len(pattern)
-            duration = 2.0 / total_points  # Total duration ~2 seconds
-            
-            for i, (x, y) in enumerate(pattern):
-                # Add slight randomness to movement speed
-                point_duration = duration * random.uniform(0.8, 1.2)
-                pyautogui.moveTo(x, y, duration=point_duration)
-                
-                # Random micro-pauses between movements
-                if i < total_points - 1:
-                    time.sleep(random.uniform(0.05, 0.15))
-            
-            logger.info("Natural mouse movement performed successfully")
-        except Exception as e:
-            logger.warning(f"Random mouse movement failed: {e}", exc_info=True)
-
     def _perform_sync_captcha_checks(self, driver: Driver):
-        # This method is now exclusively for the on-site "Verify Human" popup.
         logger.info("Checking for on-site ('Verify Human') captcha...")
-        
-        # Add random mouse movements at start
-        self._random_mouse_movement(driver)
-        
-        # First check if textarea is already interactable AND no captcha popup is visible
         try:
             textarea_locator = (By.TAG_NAME, "textarea")
-            textarea = WebDriverWait(driver, 5).until(
-                EC.element_to_be_clickable(textarea_locator)
-            )
-            
-            # Detect captcha presence with multiple strategies
+            textarea = WebDriverWait(driver, 5).until(EC.element_to_be_clickable(textarea_locator))
             captcha_present = False
-            # Allow time for captcha to render
-            time.sleep(2)
-            # 1. Check for common captcha iframes
-            try:
-                iframes = driver.find_elements(By.TAG_NAME, 'iframe')
-                for iframe in iframes:
-                    src = iframe.get_attribute('src') or ''
-                    if any(keyword in src for keyword in ['api2/anchor', 'api2/bframe', 'recaptcha', 'hcaptcha.com']):
-                        if iframe.is_displayed():
-                            captcha_present = True
-                            logger.info(f"On-site captcha iframe detected with src containing keyword.")
-                            break
-            except Exception as e:
-                logger.debug(f"Error scanning iframes for on-site captcha: {e}")
-            # 2. Check for captcha container divs
-            if not captcha_present:
+            time.sleep(10)
+            for selector in ['iframe[src*="api2/anchor"]', 'iframe[src*="recaptcha"]', '.g-recaptcha', '.h-captcha']:
                 try:
-                    containers = driver.find_elements(By.CSS_SELECTOR, '.g-recaptcha, .grecaptcha-badge, .h-captcha')
-                    for c in containers:
-                        if c.is_displayed():
-                            captcha_present = True
-                            logger.info("On-site captcha container detected via CSS selector.")
-                            break
-                except Exception as e:
-                    logger.debug(f"Error scanning on-site captcha containers: {e}")
-            # 3. Text cues
+                    if driver.find_element(By.CSS_SELECTOR, selector).is_displayed():
+                        captcha_present = True; break
+                except NoSuchElementException: continue
             if not captcha_present:
-                for cue in ['Verify you are human', 'I am not a robot']:
-                    try:
-                        elem = driver.find_element(By.XPATH, f"//*[contains(text(), '{cue}')]")
-                        if elem.is_displayed():
-                            captcha_present = True
-                            logger.info(f"On-site captcha text cue '{cue}' detected.")
-                            break
-                    except Exception:
-                        pass
-
+                try:
+                    if driver.find_element(By.XPATH, "//*[contains(text(), 'Verify you are human')]").is_displayed():
+                        captcha_present = True
+                except NoSuchElementException: pass
             if textarea.is_enabled() and textarea.is_displayed() and not captcha_present:
                 logger.info("No on-site captcha detected. Main UI is ready.")
                 return
             else:
                 logger.info("Textarea not ready or an on-site captcha indicator was found. Proceeding with AI solver.")
-                
         except (TimeoutException, NoSuchElementException):
             logger.info("Chat input textarea not interactable. Proceeding with AI captcha solver.")
         except Exception as e:
             logger.warning(f"Unexpected error checking UI state for on-site captcha: {e}", exc_info=True)
-        
         if not self._genai_client:
             logger.error("On-site captcha detected, but Gemini client not available. Cannot proceed.")
             raise LmArenaError("AI Captcha solver is required but not configured.")
-
-        # --- AI-based solver for the on-site captcha ---
         try:
             logger.info("Starting visual AI check for on-site captcha.")
             screenshot = computer_control_helper.capture_screen()
             if not screenshot:
-                logger.error("Failed to capture screen for AI captcha check.")
-                return
-            
+                logger.error("Failed to capture screen for AI captcha check."); return
             img_byte_arr = io.BytesIO()
             screenshot.save(img_byte_arr, format='PNG')
-            img_bytes = img_byte_arr.getvalue()
-
-            model_name = "gemini-2.0-flash" 
-            logger.info(f"Using Gemini model: {model_name} for on-site captcha detection.")
-
+            
+            # *** CORRECTED GEMINI API CALL ***
             contents = [
-                types.Content(
-                    role="user",
-                    parts=[
-                        types.Part.from_bytes(mime_type="image/png", data=img_bytes),
-                        types.Part.from_text(text="""find the text "Verify you are human". do not give me the coordinates of the text itself - give me the coordinates of the small box to the LEFT of the text. Example response: 
+                types.Part.from_bytes(mime_type="image/png", data=img_byte_arr.getvalue()),
+                """find the text "Verify you are human". do not give me the coordinates of the text itself - give me the coordinates of the small box to the LEFT of the text. Example response: 
 ``json
 [
   {"box_2d": [504, 151, 541, 170], "label": "box"}
 ]
 ``
 If you cannot find the checkbox, respond with "No checkbox found".
-"""),
-                    ]
-                ),
+"""
             ]
             
             generate_content_config = types.GenerateContentConfig(response_mime_type="text/plain")
             logger.info("Sending screenshot to Gemini API for analysis.")
             response_stream = self._genai_client.models.generate_content_stream(
-                model=model_name, 
+                model="gemini-2.0-flash", 
                 contents=contents,
                 config=generate_content_config,
             )
             full_response_text = "".join(chunk.text for chunk in response_stream)
             logger.info(f"Received Gemini response for on-site captcha check: {full_response_text}")
-            
             if "No checkbox found" in full_response_text:
                 logger.info("Gemini indicated no checkbox found for on-site captcha.")
             else:
@@ -348,15 +248,13 @@ If you cannot find the checkbox, respond with "No checkbox found".
                         click_target = parsed_data[0]
                 elif isinstance(parsed_data, dict) and "box_2d" in parsed_data:
                     click_target = parsed_data
-                
                 if click_target:
                     logger.info(f"On-site captcha checkbox found via Gemini. Clicking coordinates: {click_target}")
                     computer_control_helper.perform_click(click_target)
-                    time.sleep(3) # Wait after click
+                    time.sleep(3)
                     logger.info("Click performed. Now reloading page as requested for post-AI solve.")
                     self._human_like_reload(driver)
                     time.sleep(config.page_load_wait_after_refresh_seconds)
-                    logger.info("Page reloaded after AI captcha solve.")
                 else:
                     logger.info("No valid 'box_2d' data found in Gemini response. Reloading as fallback.")
                     self._human_like_reload(driver)
@@ -367,154 +265,89 @@ If you cannot find the checkbox, respond with "No checkbox found".
         async with self._lock:
             if self._driver:
                 logger.info("Cleaning up and quitting Selenium driver...")
-                loop = asyncio.get_event_loop()
-                driver_to_quit = self._driver
-                self._driver = None
+                loop, driver_to_quit, self._driver = asyncio.get_event_loop(), self._driver, None
                 try:
                     await loop.run_in_executor(None, driver_to_quit.quit)
                     logger.info("Driver quit successfully.")
                 except Exception as e:
                     logger.error(f"Error during driver cleanup: {e}", exc_info=True)
-            else:
-                logger.info("Cleanup called but no driver was active.")
 
     def get_driver(self) -> Driver:
-        if self._driver is None:
-            logger.error("Attempted to get driver, but it is not available.")
-            raise DriverNotAvailableError("Driver not available")
-        logger.debug("Driver instance requested and provided.")
+        if self._driver is None: raise DriverNotAvailableError("Driver not available")
         return self._driver
     
     async def _select_model(self, model_id: str) -> None:
-        """Select a model on the LmArena page"""
         driver = self.get_driver()
         logger.info(f"Selecting model: {model_id}")
-
         def _sync_select_model_logic(drv: Driver, m_id: str):
-            logger.debug("Starting model selection logic")
             try:
-                # Click model dropdown
-                logger.debug("Locating model dropdown")
                 dropdown_locator = (By.XPATH, "//button[@data-sentry-source-file='select-model.tsx' and @role='combobox']")
-                WebDriverWait(drv, config.driver_timeout).until(
-                    EC.element_to_be_clickable(dropdown_locator)
-                ).click()
-                logger.debug("Clicked model dropdown")
-
-                # Enter model name
-                logger.debug("Locating model search input")
+                WebDriverWait(drv, config.driver_timeout).until(EC.element_to_be_clickable(dropdown_locator)).click()
                 search_locator = (By.XPATH, "//input[@placeholder='Search models' and @cmdk-input]")
-                search_element = WebDriverWait(drv, config.driver_timeout).until(
-                    EC.visibility_of_element_located(search_locator)
-                )
-                logger.debug("Clearing search input")
+                search_element = WebDriverWait(drv, config.driver_timeout).until(EC.visibility_of_element_located(search_locator))
                 search_element.clear()
-                logger.debug(f"Typing model name: {m_id}")
                 search_element.send_keys(m_id)
-                logger.debug("Sending ENTER key")
                 search_element.send_keys(Keys.ENTER)
                 logger.info(f"Selected model: {m_id}")
-
-            except (NoSuchElementException, TimeoutException) as e_se_to:
-                logger.warning(f"Model selection for '{m_id}' failed due to {type(e_se_to).__name__}.")
-                raise ModelSelectionError(f"Failed to select model {m_id}. Original error: {type(e_se_to).__name__}") from e_se_to
+            except (NoSuchElementException, TimeoutException) as e:
+                raise ModelSelectionError(f"Failed to select model {m_id}. Original error: {type(e).__name__}") from e
             except Exception as e_sync:
-                logger.error(f"Model selection failed for {m_id} with an unexpected error: {e_sync}", exc_info=True)
                 raise ModelSelectionError(f"Failed to select model {m_id}") from e_sync
-
-        loop = asyncio.get_event_loop()
         try:
-            await loop.run_in_executor(None, _sync_select_model_logic, driver, model_id)
-        except ModelSelectionError:
-            raise
+            await asyncio.get_event_loop().run_in_executor(None, _sync_select_model_logic, driver, model_id)
+        except ModelSelectionError: raise
         except Exception as e_exec:
-            logger.error(f"Error executing _select_model in executor: {e_exec}", exc_info=True)
             raise ModelSelectionError(f"Failed to select model {model_id} due to executor error: {e_exec}") from e_exec
 
     async def _retry_with_reload(self, driver: Driver, model_id: str):
-        """Handle ModelSelectionError by reloading and retrying once"""
         try:
-            # Manual reload simulation
             pyautogui.press('f5')
             time.sleep(0.5)
-            # Hard refresh (Ctrl+F5) - simulates FN+F5 behavior
-            pyautogui.keyDown('ctrl')
-            time.sleep(0.3)
-            pyautogui.press('f5')
-            time.sleep(0.3)
-            pyautogui.keyUp('ctrl')
-            
-            # Wait for page reload
-            WebDriverWait(driver, config.page_load_wait_after_refresh_seconds).until(
-                EC.presence_of_element_located((By.XPATH, "//input[@placeholder='Search models' and @cmdk-input]"))
-            )
-            
-            # Retry model selection
+            pyautogui.keyDown('ctrl'); time.sleep(0.3); pyautogui.press('f5'); time.sleep(0.3); pyautogui.keyUp('ctrl')
+            WebDriverWait(driver, config.page_load_wait_after_refresh_seconds).until(EC.presence_of_element_located((By.XPATH, "//input[@placeholder='Search models' and @cmdk-input]")))
             await self._select_model(model_id)
-            
         except Exception as reload_err:
             logger.error(f"Reload and retry failed: {reload_err}", exc_info=True)
-            # Capture screenshot after failed reload
-            png = driver.get_screenshot_as_png()
-            b64 = base64.b64encode(png).decode('utf-8')
+            with mss.mss() as sct:
+                img = Image.frombytes("RGB", sct.grab(sct.monitors[1]).size, sct.grab(sct.monitors[1]).bgra, "raw", "BGRX")
+                img_bytes = io.BytesIO(); img.save(img_bytes, format="PNG")
+                b64 = base64.b64encode(img_bytes.getvalue()).decode('utf-8')
             logger.error(f"Screenshot base64 after failed reload: {b64}")
             raise ModelSelectionError(f"Failed after reload attempt: {reload_err}") from reload_err
 
     def generate_reload_button_location(self, driver: Driver) -> str:
-        # This function is not used by the refined captcha logic, but keeping it as it might be used elsewhere.
         logger.info("Generating reload button location with Gemini")
         try:
-            # Capture screenshot
-            screenshot = computer_control_helper.capture_screen()
-            if not screenshot:
-                logger.error("Failed to capture screen for reload button detection")
-                return "[]"
-            
-            img_byte_arr = io.BytesIO()
-            screenshot.save(img_byte_arr, format='PNG')
-            img_bytes = img_byte_arr.getvalue()
-            
-            model_name = "gemini-2.0-flash"
+            with mss.mss() as sct:
+                img = Image.frombytes("RGB", sct.grab(sct.monitors[1]).size, sct.grab(sct.monitors[1]).bgra, "raw", "BGRX")
+                img_bytes = io.BytesIO(); img.save(img_bytes, format="PNG"); img_bytes = img_bytes.getvalue()
+
+            # *** CORRECTED GEMINI API CALL ***
             contents = [
-                types.Content(
-                    role="user",
-                    parts=[
-                        types.Part.from_bytes(mime_type="image/png", data=img_bytes),
-                        types.Part.from_text(text="""Find the reload button on the page. It might be labeled with words like "Reload", "Refresh", or have a circular arrow icon. Return the coordinates of the button in the following format:
+                types.Part.from_bytes(mime_type="image/png", data=img_bytes),
+                """Find the reload button on the page. It might be labeled with words like "Reload", "Refresh", or have a circular arrow icon. Return the coordinates of the button in the following format:
 ``json
 [
   {"box_2d": [x1, y1, x2, y2], "label": "reload button"}
 ]
 ``
 If you cannot find the reload button, respond with "No reload button found".
-""")
-                    ]
-                )
+"""
             ]
-            
+
             generate_content_config = types.GenerateContentConfig(response_mime_type="text/plain")
-            response_stream = self._genai_client.models.generate_content_stream(
-                model=model_name, 
-                contents=contents,
-                config=generate_content_config,
-            )
+            response_stream = self._genai_client.models.generate_content_stream(model="gemini-2.0-flash", contents=contents, config=generate_content_config)
             full_response_text = "".join(chunk.text for chunk in response_stream)
             logger.info(f"Gemini response for reload button: {full_response_text}")
-            # If AI couldn't find the reload button, simulate manual F5 and FN+F5 keystrokes (without .refresh()), take screenshot and log base64
             if "No reload button found" in full_response_text:
                 logger.info("AI did not find reload button, performing manual F5 and FN+F5 reloads.")
                 try:
-                    pyautogui.press('f5')
-                    time.sleep(0.5)
-                    pyautogui.keyDown('ctrl')
-                    time.sleep(0.3)
-                    pyautogui.press('f5')
-                    time.sleep(0.3)
-                    pyautogui.keyUp('ctrl')
-                    time.sleep(0.5)
-                    # Capture screenshot after manual reload
-                    png2 = driver.get_screenshot_as_png()
-                    b64_2 = base64.b64encode(png2).decode('utf-8')
+                    pyautogui.press('f5'); time.sleep(0.5)
+                    pyautogui.keyDown('ctrl'); time.sleep(0.3); pyautogui.press('f5'); time.sleep(0.3); pyautogui.keyUp('ctrl'); time.sleep(0.5)
+                    with mss.mss() as sct:
+                        img = Image.frombytes("RGB", sct.grab(sct.monitors[1]).size, sct.grab(sct.monitors[1]).bgra, "raw", "BGRX")
+                        img_bytes = io.BytesIO(); img.save(img_bytes, format="PNG")
+                        b64_2 = base64.b64encode(img_bytes.getvalue()).decode('utf-8')
                     logger.info(f"Screenshot base64 after manual reload: {b64_2}")
                 except Exception as manu_err:
                     logger.error(f"Manual reload simulation failed: {manu_err}", exc_info=True)
@@ -527,20 +360,19 @@ driver_manager = DriverManager()
 
 class ChatHandler:
     @staticmethod
-    async def send_message_and_stream_response(prompt: str, model_id: str):
+    async def send_message_and_stream_response(prompt: str, model_id: str, stream_raw_html: bool = False, convert_html_to_markdown: bool = True):
         driver = driver_manager.get_driver()
         request_id = str(uuid.uuid4())
-        logger.info(f"[{request_id}] Starting chat interaction. Model: '{model_id}'.")
+        logger.info(f"[{request_id}] Starting chat. Model: '{model_id}', RawHTML: {stream_raw_html}, MarkdownMode: {convert_html_to_markdown}.")
         try:
             if model_id:
-                logger.info(f"[{request_id}] Model specified, selecting '{model_id}'.")
                 await driver_manager._select_model(model_id)
             sanitized_prompt = ChatHandler._sanitize_for_bmp(prompt)
             logger.info(f"[{request_id}] Sending prompt (first 50 chars): '{sanitized_prompt[:50]}...'")
             await ChatHandler._send_prompt(driver, sanitized_prompt)
             await ChatHandler._handle_agreement_dialog(driver)
             logger.info(f"[{request_id}] Prompt sent. Streaming response...")
-            async for chunk in ChatHandler._stream_response(driver, sanitized_prompt, model_id):
+            async for chunk in ChatHandler._stream_response(driver, stream_raw_html, convert_html_to_markdown):
                 yield chunk
             logger.info(f"[{request_id}] Finished streaming response from browser.")
         except Exception as e:
@@ -555,66 +387,57 @@ class ChatHandler:
 
     @staticmethod
     def _sanitize_for_bmp(text: str) -> str:
-        # This function is simple, so logging is omitted unless for debugging
         return ''.join(c for c in text if ord(c) <= 0xFFFF)
     
     @staticmethod
     async def _send_prompt(driver: Driver, prompt: str):
         logger.info("Typing prompt into textarea.")
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, lambda: driver.type('textarea', prompt + "\n"))
+        await asyncio.get_event_loop().run_in_executor(None, lambda: driver.type('textarea', prompt + "\n"))
         logger.info("Prompt submitted.")
     
     @staticmethod
     async def _handle_agreement_dialog(driver: Driver):
         logger.info("Checking for 'Agree' button in dialog.")
-        loop = asyncio.get_event_loop()
-        clicked = await loop.run_in_executor(None, lambda: driver.click_if_visible("//button[normalize-space()='Agree']"))
-        if clicked:
+        if await asyncio.get_event_loop().run_in_executor(None, lambda: driver.click_if_visible("//button[normalize-space()='Agree']", timeout=1)):
             logger.info("'Agree' button found and clicked.")
         else:
             logger.info("'Agree' button not visible, skipping.")
     
     @staticmethod
-    async def _stream_response(driver: Driver, prompt: str, model: str) -> AsyncGenerator[str, None]:
-        """Stream response using stabilization-based approach with a corrected locator."""
+    async def _stream_response(driver: Driver, stream_raw_html: bool, convert_html_to_markdown: bool) -> AsyncGenerator[str, None]:
         try:
+            # *** CORRECTED XPATH ***: Restored your original, more robust XPath selector.
             content_container_locator = (By.XPATH, "(//ol[contains(@class, 'flex-col-reverse')]/div[.//h2[starts-with(@id, 'radix-')]])[1]//div[contains(@class, 'grid') and contains(@class, 'pt-4')]")
-
-            WebDriverWait(driver, config.response_timeout).until(
-                EC.presence_of_element_located(content_container_locator)
-            )
-            logger.info("Assistant response container found. Starting to poll for text.")
             
-            stream_processor = StreamProcessor(config=StreamConfig(
+            WebDriverWait(driver, config.response_timeout).until(EC.presence_of_element_located(content_container_locator))
+            
+            stream_config = StreamConfig(
                 poll_interval=config.poll_interval,
                 response_timeout=config.response_timeout,
                 stabilization_timeout=config.stabilization_timeout,
-                max_inactivity=config.max_inactivity
-            ))
+                max_inactivity=config.max_inactivity,
+                stream_raw_html=stream_raw_html,
+                convert_html_to_markdown=convert_html_to_markdown
+            )
+            stream_processor = StreamProcessor(config=stream_config)
             
-            text_stream = stream_processor.poll_element_text_stream(
+            processed_stream_iterator = stream_processor.get_processed_text_stream(
                 driver=driver,
                 element_locator=content_container_locator
             )
             
-            stabilized_stream = stream_processor.read_stream_with_stabilization(
-                text_stream
-            )
-            
-            async for chunk in ChatHandler._sync_to_async(stabilized_stream):
+            async for chunk in ChatHandler._sync_to_async(processed_stream_iterator):
                 yield chunk
                 
         except TimeoutException:
-            logger.error(f"Streaming error: Timed out waiting for response container to appear.", exc_info=True)
-            yield f"\n\nError: Timed out waiting for response from the page."
+            logger.error("Streaming error: Timed out waiting for response container to appear.", exc_info=True)
+            yield "\n\nError: Timed out waiting for response from the page."
         except Exception as e:
             logger.error(f"Streaming error: {e}", exc_info=True)
             yield f"\n\nError: {str(e)}"
     
     @staticmethod
     async def _sync_to_async(sync_iter: Iterator[str]) -> AsyncGenerator[str, None]:
-        """Convert synchronous iterator to async generator"""
         for item in sync_iter:
             yield item
             await asyncio.sleep(0)
@@ -622,60 +445,32 @@ class ChatHandler:
     @staticmethod
     async def _click_new_chat(driver: Driver, request_id: str):
         logger.info(f"[{request_id}] Attempting to click 'New Chat' button.")
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, lambda: driver.click("//a[contains(@class, 'whitespace-nowrap') and .//h2[contains(text(), 'New Chat')]]"))
+        await asyncio.get_event_loop().run_in_executor(None, lambda: driver.click("//a[contains(@class, 'whitespace-nowrap') and .//h2[contains(text(), 'New Chat')]]"))
         logger.info(f"[{request_id}] 'New Chat' button clicked successfully.")
 
 async def get_available_models() -> List[str]:
-    """Scrapes the list of available models from the UI."""
     driver = driver_manager.get_driver()
-    loop = asyncio.get_event_loop()
-
     def _sync_scrape_models(drv: Driver) -> List[str]:
         logger.info("Scraping available models...")
         dropdown_locator = (By.XPATH, "//button[@data-sentry-source-file='select-model.tsx' and @role='combobox']")
         model_item_locator = (By.XPATH, "//div[@cmdk-item and @data-value]")
-
         try:
-            # Click the dropdown to open it
-            dropdown_button = WebDriverWait(drv, config.driver_timeout).until(
-                EC.element_to_be_clickable(dropdown_locator)
-            )
-            dropdown_button.click()
-            logger.info("Model dropdown clicked.")
-
-            # Wait for the list items to be present
-            WebDriverWait(drv, config.driver_timeout).until(
-                EC.presence_of_all_elements_located(model_item_locator)
-            )
-            logger.info("Model list is visible.")
-            time.sleep(0.5)  # Brief pause for full render
-
-            # Scrape the model names from the 'data-value' attribute
-            model_elements = drv.find_elements(*model_item_locator)
-            model_ids = [elem.get_attribute('data-value') for elem in model_elements if elem.get_attribute('data-value')]
+            dropdown_button = WebDriverWait(drv, config.driver_timeout).until(EC.element_to_be_clickable(dropdown_locator))
+            dropdown_button.click(); logger.info("Model dropdown clicked.")
+            WebDriverWait(drv, config.driver_timeout).until(EC.presence_of_all_elements_located(model_item_locator)); time.sleep(0.5)
+            model_ids = [elem.get_attribute('data-value') for elem in drv.find_elements(*model_item_locator) if elem.get_attribute('data-value')]
             logger.info(f"Found {len(model_ids)} models.")
-
-            # Click the dropdown again to close it
-            dropdown_button.click()
-            logger.info("Closed model dropdown.")
-            
+            dropdown_button.click(); logger.info("Closed model dropdown.")
             return model_ids
         except (TimeoutException, NoSuchElementException) as e:
             logger.error(f"Failed to scrape models: {e}", exc_info=True)
-            # Attempt to restore state by clicking dropdown again, in case it's stuck open
-            try:
-                drv.find_element(*dropdown_locator).click()
-            except Exception as close_e:
-                logger.warning(f"Could not close model dropdown after error: {close_e}")
+            try: drv.find_element(*dropdown_locator).click()
+            except Exception as close_e: logger.warning(f"Could not close model dropdown after error: {close_e}")
             raise LmArenaError(f"Could not find or interact with the model dropdown: {e}") from e
-
     try:
-        model_list = await loop.run_in_executor(None, _sync_scrape_models, driver)
-        return model_list
+        return await asyncio.get_event_loop().run_in_executor(None, _sync_scrape_models, driver)
     except Exception as e:
-        logger.error(f"Error executing model scraping in executor: {e}", exc_info=True)
-        raise
+        logger.error(f"Error executing model scraping in executor: {e}", exc_info=True); raise
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -685,9 +480,7 @@ async def lifespan(app: FastAPI):
         logger.info("Application startup sequence completed successfully.")
     except Exception as e:
         logger.critical(f"A critical error occurred during application startup: {e}", exc_info=True)
-        # Ensure cleanup is called if initialization fails at any point
-        await driver_manager.cleanup() 
-        raise
+        await driver_manager.cleanup(); raise
     yield
     logger.info("Application shutdown sequence initiated.")
     await driver_manager.cleanup()
@@ -695,121 +488,71 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(lifespan=lifespan)
 
-@app.middleware("http")
-async def error_screenshot_middleware(request: Request, call_next):
-    try:
-        return await call_next(request)
-    except Exception as exc:
-        logger.error(f"Unhandled exception: {exc}", exc_info=True)
-        try:
-            driver = driver_manager.get_driver()
-            png = driver.get_screenshot_as_png()
-            b64 = base64.b64encode(png).decode('utf-8')
-            logger.error(f"Screenshot base64: {b64}")
-        except Exception as capture_err:
-            logger.error(f"Failed to capture screenshot: {capture_err}", exc_info=True)
-        raise
-
 @app.get("/health")
 async def health_check():
-    logger.info("Health check endpoint called.")
     try:
         driver_manager.get_driver()
-        logger.info("Health check status: healthy, driver is available.")
         return {"status": "healthy", "driver": "available"}
     except DriverNotAvailableError:
-        logger.warning("Health check status: unhealthy, driver is unavailable.")
         return {"status": "unhealthy", "driver": "unavailable"}
 
 @app.get("/models", response_model=ModelListResponse)
 async def list_models():
-    """Returns a list of available models."""
     logger.info("Received request for /models endpoint.")
     try:
         model_ids = await get_available_models()
-        model_data = [ModelInfo(id=model_id) for model_id in model_ids]
-        return ModelListResponse(data=model_data)
+        return ModelListResponse(data=[ModelInfo(id=model_id) for model_id in model_ids])
     except DriverNotAvailableError:
-        logger.error("Models endpoint called but driver is not available.")
         raise HTTPException(status_code=503, detail="Service unavailable: The backend driver is not ready.")
     except Exception as e:
         logger.error(f"An unexpected error occurred while fetching models: {e}", exc_info=True)
-        try:
-            driver = driver_manager.get_driver()
-            logger.info("Attempting captcha solve after models fetch error...")
-            driver.uc_gui_click_captcha()
-            driver_manager._perform_sync_captcha_checks(driver)
-            png = driver.get_screenshot_as_png()
-            b64 = base64.b64encode(png).decode('utf-8')
-            logger.error(f"Screenshot base64 after captcha solve: {b64}")
-        except Exception as captcha_err:
-            logger.error(f"Failed captcha solve/screenshot in models endpoint: {captcha_err}", exc_info=True)
-        raise HTTPException(status_code=500, detail="An unexpected error occurred while fetching models: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred while fetching models: {str(e)}")
 
 @app.post("/chat/completions", response_model=ChatCompletionResponse)
 async def chat_completions(request: ChatCompletionRequest):
-    completion_id = f"chatcmpl-{uuid.uuid4().hex}"
-    created_timestamp = int(time.time())
-    logger.info(f"[{completion_id}] Received chat completion request for model '{request.model}', stream={request.stream}.")
+    completion_id, created_timestamp = f"chatcmpl-{uuid.uuid4().hex}", int(time.time())
+    logger.info(f"[{completion_id}] Received chat completion request: model='{request.model}', stream={request.stream}, md_convert={request.convert_html_to_markdown}")
     full_prompt = "\n".join([msg.content for msg in request.messages if isinstance(msg.content, str)])
     try:
         driver_manager.get_driver()
+        send_message_func = lambda p, m: ChatHandler.send_message_and_stream_response(
+            prompt=p, model_id=m, stream_raw_html=request.stream_raw_html, convert_html_to_markdown=request.convert_html_to_markdown
+        )
         if request.stream:
-            logger.info(f"[{completion_id}] Handling as a streaming request.")
             return StreamingResponse(
                 create_streaming_response(
-                    completion_id, 
-                    created_timestamp, 
-                    request.model, 
-                    full_prompt,
-                    ChatHandler.send_message_and_stream_response
-                ),
-                media_type="text/event-stream"
+                    completion_id=completion_id, created=created_timestamp, model=request.model, prompt=full_prompt, send_message_func=send_message_func
+                ), media_type="text/event-stream"
             )
         else:
-            logger.info(f"[{completion_id}] Handling as a non-streaming request.")
             return await _create_non_streaming_response(
-                completion_id, created_timestamp, request.model, full_prompt
+                completion_id, created_timestamp, request.model, full_prompt, request.convert_html_to_markdown
             )
     except DriverNotAvailableError as e:
-        logger.error(f"[{completion_id}] Service unavailable: The backend driver is not ready. Error: {e}", exc_info=True)
         raise HTTPException(status_code=503, detail="Service unavailable: The backend driver is not ready.")
     except APIError as e:
-        logger.error(f"[{completion_id}] API Error occurred: {e.message} (Status: {e.status_code})", exc_info=True)
         raise HTTPException(status_code=e.status_code, detail=e.message)
     except Exception as e:
-        logger.error(f"[{completion_id}] An unexpected processing error occurred: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"An unexpected processing error occurred: {str(e)}")
 
-async def _create_non_streaming_response(completion_id: str, created: int, model: str, prompt: str) -> ChatCompletionResponse:
-    logger.info(f"[{completion_id}] Creating non-streaming response.")
+async def _create_non_streaming_response(completion_id: str, created: int, model: str, prompt: str, convert_html_to_markdown: bool) -> ChatCompletionResponse:
     try:
-        content_parts = [chunk async for chunk in ChatHandler.send_message_and_stream_response(prompt, model)]
+        content_parts = [chunk async for chunk in ChatHandler.send_message_and_stream_response(prompt, model, stream_raw_html=False, convert_html_to_markdown=convert_html_to_markdown)]
         final_content = "".join(content_parts)
-        logger.info(f"[{completion_id}] Non-streaming response generated successfully. Content length: {len(final_content)}.")
         return ChatCompletionResponse(
-            id=completion_id,
-            object="chat.completion",
-            created=created,
-            model=model,
+            id=completion_id, object="chat.completion", created=created, model=model,
             choices=[Choice(index=0, message={"role": "assistant", "content": final_content}, finish_reason="stop")],
             usage=Usage(prompt_tokens=0, completion_tokens=0, total_tokens=0)
         )
-    except APIError:
-        logger.error(f"[{completion_id}] APIError during non-streaming response creation.", exc_info=True)
-        raise
     except Exception as e:
         logger.error(f"[{completion_id}] Exception during non-streaming response creation: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail="Error processing non-streaming request.")
 
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting application...")
     if not os.getenv("GEMINI_API_KEY"):
         logger.error("FATAL: GEMINI_API_KEY environment variable not set. Captcha solving will be disabled.")
-        print("ERROR: GEMINI_API_KEY environment variable not set.")
     else:
         logger.info("GEMINI_API_KEY is set.")
-
     logger.info("Starting Uvicorn server on 0.0.0.0:8000.")
     uvicorn.run(app, host="0.0.0.0", port=8000)

computer_control_helper.py

@@ -3,21 +3,9 @@
 from PIL import Image, ImageDraw, ImageFont
 import pyautogui
 import mss # For screen capture
-import io
 import json
 import os
 import time, datetime
-import sys
-
-
-DEBUG_DIR = "debug_screenshots"
-try:
-        os.makedirs(DEBUG_DIR, exist_ok=True)
-        print(f"Debug screenshots will be saved to: {os.path.abspath(DEBUG_DIR)}")
-except OSError as e:
-        print(f"Error creating debug directory '{DEBUG_DIR}': {e}")
-        # Decide if you want to exit or just continue without saving debug images
-        DEBUG_DIR = None # Disable saving if directory creation fails
 
 def parse_json_safely(json_string: str) -> dict:
     """
@@ -568,89 +556,6 @@ def perform_press_key(location_data: dict):
         return False
 
 
-def save_debug_screenshot(image: Image.Image, location_data: dict, task_desc: str, step: int, output_dir: str):
-    """Saves the image with the detected bounding box drawn on it."""
-    if not output_dir:
-        print("Debug directory not configured. Skipping debug image save.")
-        return
-    if not image:
-        print("No image provided to save_debug_screenshot.")
-        return
-    if not location_data or "box_2d" not in location_data:
-        print("No bounding box data to draw for debug image.")
-        # Optionally save the plain screenshot anyway
-        # filename = f"debug_{datetime.datetime.now():%Y%m%d_%H%M%S}_step{step}_nobox.png"
-        # image.save(os.path.join(output_dir, filename))
-        return
-
-    try:
-        # Apply grid overlay first
-        img_copy = draw_grid_overlay(image)
-        
-        draw = ImageDraw.Draw(img_copy)
-        box = location_data["box_2d"]
-        label = location_data.get("label", "Unknown")
-
-        # Use image dimensions for denormalization when drawing
-        width, height = img_copy.size
-
-        # Denormalize coordinates (Gemini uses y_min, x_min, y_max, x_max from 0-1000)
-        y_min_norm, x_min_norm, y_max_norm, x_max_norm = box
-
-        # Validation (optional but good)
-        if not all(isinstance(coord, (int, float)) and 0 <= coord <= 1000 for coord in box):
-             print(f"Warning: Invalid normalized coordinates in debug save: {box}")
-             return
-        if x_min_norm >= x_max_norm or y_min_norm >= y_max_norm:
-             print(f"Warning: Invalid box (min>=max) in debug save: {box}")
-             # Decide if you still want to draw/save
-
-        abs_x_min = int(x_min_norm / 1000 * width)
-        abs_y_min = int(y_min_norm / 1000 * height)
-        abs_x_max = int(x_max_norm / 1000 * width)
-        abs_y_max = int(y_max_norm / 1000 * height)
-
-        # Draw rectangle
-        outline_color = "red"
-        draw.rectangle(
-            ((abs_x_min, abs_y_min), (abs_x_max, abs_y_max)),
-            outline=outline_color,
-            width=3 # Make it visible
-        )
-
-        # Draw label (optional, requires a font)
-        try:
-            # Try a common system font, adjust path if needed or remove if font hassle is too much
-            font_size = 16
-            font = ImageFont.truetype("arial.ttf", font_size) # Adjust path/name as needed
-            text_position = (abs_x_min + 5, abs_y_min - font_size - 2 if abs_y_min > font_size else abs_y_min + 5)
-            # Simple background for text readability
-            text_bbox = draw.textbbox(text_position, label, font=font)
-            draw.rectangle(text_bbox, fill="white")
-            draw.text(text_position, label, fill=outline_color, font=font)
-        except IOError:
-            print("Warning: Font for debug label not found. Skipping label.")
-            # Fallback: draw text without specific font (might be tiny/ugly)
-            # draw.text((abs_x_min + 5, abs_y_min + 5), label, fill=outline_color)
-        except Exception as e:
-            print(f"Warning: Error loading font or drawing text: {e}")
-
-
-        # Create filename
-        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3] # Added milliseconds
-        # Sanitize task description slightly for filename
-        safe_task_desc = "".join(c if c.isalnum() else "_" for c in task_desc[:5]) # Limit length
-        filename = f"debug_{timestamp}_step{step}_{safe_task_desc}.png"
-        filepath = os.path.join(output_dir, filename)
-
-        # Save the image
-        img_copy.save(filepath)
-        print(f"Debug image saved: {filepath}")
-
-    except Exception as e:
-        print(f"Error saving debug screenshot: {e}")
-
-
 max_steps = 100 # Safety break to prevent infinite loops
 
 
@@ -669,10 +574,6 @@ def do_task(original_task, task_not_complted):
                 # Parse the json input
                 step_info = parse_json_safely(original_task)
 
-                # Save debug screenshot *with* action info if available
-                if DEBUG_DIR and screen_image:
-                    save_debug_screenshot(screen_image, step_info, original_task, step_count, DEBUG_DIR)
-
                 # 3. Extract info from Gemini's response
                 action_type = step_info.get("action_type") # Get the action type
                 task_not_completed = step_info.get("task_not_completed", False) # Default to False if missing

lmarena.log

@@ -0,0 +1,790 @@
+2025-06-09 12:15:57,895 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:15:57,902 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:15:58,475 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:15:58,532 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:15:58,532 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:15:58,569 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:15:58,570 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:15:58,572 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:16:02,376 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:16:07,588 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:16:07,589 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:16:23,430 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:16:23,431 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:16:27,502 - __main__ - WARNING - Unexpected error checking UI state for on-site captcha: Message: invalid session id: session deleted as the browser has closed the connection
+from disconnected: not connected to DevTools
+  (Session info: chrome=137.0.7151.69)
+Stacktrace:
+	GetHandleVerifier [0x0x7ff748e66f65+78965]
+	GetHandleVerifier [0x0x7ff748e66fc0+79056]
+	(No symbol) [0x0x7ff748bf9dda]
+	(No symbol) [0x0x7ff748be5bc5]
+	(No symbol) [0x0x7ff748c0ac04]
+	(No symbol) [0x0x7ff748c80195]
+	(No symbol) [0x0x7ff748ca06cd]
+	(No symbol) [0x0x7ff748c78443]
+	(No symbol) [0x0x7ff748c41311]
+	(No symbol) [0x0x7ff748c420a3]
+	GetHandleVerifier [0x0x7ff74911e26d+2926461]
+	GetHandleVerifier [0x0x7ff749118993+2903715]
+	GetHandleVerifier [0x0x7ff749136aed+3026941]
+	GetHandleVerifier [0x0x7ff748e816fe+187406]
+	GetHandleVerifier [0x0x7ff748e896ef+220159]
+	GetHandleVerifier [0x0x7ff748e6faf4+114692]
+	GetHandleVerifier [0x0x7ff748e6fca9+115129]
+	GetHandleVerifier [0x0x7ff748e564d8+10728]
+	BaseThreadInitThunk [0x0x7ffd6f06e8d7+23]
+	RtlUserThreadStart [0x0x7ffd6fafc5dc+44]
+Traceback (most recent call last):
+  File "c:\Users\caree\Code\Lmarena\api.py", line 186, in _perform_sync_captcha_checks
+    textarea = WebDriverWait(driver, 5).until(EC.element_to_be_clickable(textarea_locator))
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\support\wait.py", line 129, in until
+    value = method(self._driver)
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\support\expected_conditions.py", line 622, in _predicate
+    target = driver.find_element(*target)  # grab element at locator
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\seleniumbase\core\sb_driver.py", line 27, in find_element
+    return self.driver.default_find_element(by=by, value=value)
+           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\remote\webdriver.py", line 914, in find_element
+    return self.execute(Command.FIND_ELEMENT, {"using": by, "value": value})["value"]
+           ~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\remote\webdriver.py", line 447, in execute
+    self.error_handler.check_response(response)
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\remote\errorhandler.py", line 232, in check_response
+    raise exception_class(message, screen, stacktrace)
+selenium.common.exceptions.InvalidSessionIdException: Message: invalid session id: session deleted as the browser has closed the connection
+from disconnected: not connected to DevTools
+  (Session info: chrome=137.0.7151.69)
+Stacktrace:
+	GetHandleVerifier [0x0x7ff748e66f65+78965]
+	GetHandleVerifier [0x0x7ff748e66fc0+79056]
+	(No symbol) [0x0x7ff748bf9dda]
+	(No symbol) [0x0x7ff748be5bc5]
+	(No symbol) [0x0x7ff748c0ac04]
+	(No symbol) [0x0x7ff748c80195]
+	(No symbol) [0x0x7ff748ca06cd]
+	(No symbol) [0x0x7ff748c78443]
+	(No symbol) [0x0x7ff748c41311]
+	(No symbol) [0x0x7ff748c420a3]
+	GetHandleVerifier [0x0x7ff74911e26d+2926461]
+	GetHandleVerifier [0x0x7ff749118993+2903715]
+	GetHandleVerifier [0x0x7ff749136aed+3026941]
+	GetHandleVerifier [0x0x7ff748e816fe+187406]
+	GetHandleVerifier [0x0x7ff748e896ef+220159]
+	GetHandleVerifier [0x0x7ff748e6faf4+114692]
+	GetHandleVerifier [0x0x7ff748e6fca9+115129]
+	GetHandleVerifier [0x0x7ff748e564d8+10728]
+	BaseThreadInitThunk [0x0x7ffd6f06e8d7+23]
+	RtlUserThreadStart [0x0x7ffd6fafc5dc+44]
+
+2025-06-09 12:16:27,507 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 12:16:27,663 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 12:16:27,663 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 12:16:27,664 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 12:16:30,777 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 12:16:30,849 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [495, 138, 527, 151], "label": "box"}
+]
+```
+2025-06-09 12:16:30,849 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [495, 138, 527, 151], 'label': 'box'}
+2025-06-09 12:16:42,537 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:16:42,542 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:16:43,027 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:16:43,065 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:16:43,065 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:16:43,090 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:16:43,091 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:16:43,092 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:16:46,172 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:16:53,140 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:16:53,141 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:16:53,588 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:16:53,589 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:16:55,688 - __main__ - INFO - No on-site captcha detected. Main UI is ready.
+2025-06-09 12:16:55,688 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 12:16:55,689 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 12:17:39,593 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 12:17:39,593 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 12:17:41,909 - __main__ - INFO - Driver quit successfully.
+2025-06-09 12:17:41,909 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 12:18:55,881 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:18:55,887 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:18:56,388 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:18:56,424 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:18:56,425 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:18:56,450 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:18:56,451 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:18:56,452 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:18:59,568 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:19:07,244 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:19:07,244 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:19:07,251 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:19:07,252 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:19:12,372 - __main__ - INFO - Chat input textarea not interactable. Proceeding with AI captcha solver.
+2025-06-09 12:19:12,374 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 12:19:12,539 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 12:19:12,539 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 12:19:12,539 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 12:19:15,352 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 12:19:15,478 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [578, 166, 612, 185], "label": "box"}
+]
+```
+2025-06-09 12:19:15,478 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [578, 166, 612, 185], 'label': 'box'}
+2025-06-09 12:19:19,272 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 12:19:19,272 - __main__ - INFO - Performing human-like page reload
+2025-06-09 12:19:19,273 - __main__ - INFO - Using FN+F5 key combination
+2025-06-09 12:19:21,438 - __main__ - INFO - Page reloaded after 1.26s delay
+2025-06-09 12:19:26,439 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 12:19:26,439 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 12:19:44,775 - __main__ - INFO - [chatcmpl-1503f2e8146f468993892ee257265847] Received chat completion request: model='qwen no think', stream=True, md_convert=True
+2025-06-09 12:19:44,788 - streaming - INFO - [chatcmpl-1503f2e8146f468993892ee257265847] Starting streaming response generation for model 'qwen no think'.
+2025-06-09 12:19:44,788 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] Starting chat. Model: 'qwen no think', RawHTML: False, MarkdownMode: True.
+2025-06-09 12:19:44,788 - __main__ - INFO - Selecting model: qwen no think
+2025-06-09 12:19:45,064 - __main__ - INFO - Selected model: qwen no think
+2025-06-09 12:19:45,065 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] Sending prompt (first 50 chars): 'python pascals tree gen small concise code no comm...'
+2025-06-09 12:19:45,065 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 12:19:45,465 - __main__ - INFO - Prompt submitted.
+2025-06-09 12:19:45,466 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 12:19:45,559 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 12:19:45,559 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] Prompt sent. Streaming response...
+2025-06-09 12:19:51,721 - streaming - INFO - [StreamProc/Process] Starting stream in Markdown conversion mode.
+2025-06-09 12:20:05,631 - streaming - INFO - [StreamProc/PollStream] Content hasn't changed for 10.00s. Assuming stable.
+2025-06-09 12:20:05,632 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] Finished streaming response from browser.
+2025-06-09 12:20:05,632 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 12:20:05,633 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] Attempting to click 'New Chat' button.
+2025-06-09 12:20:05,720 - __main__ - INFO - [98806519-9b36-4d7a-9c31-66529703a72f] 'New Chat' button clicked successfully.
+2025-06-09 12:20:05,721 - streaming - INFO - [chatcmpl-1503f2e8146f468993892ee257265847] Yielding final chunk. Total content length: 356 chars.
+2025-06-09 12:20:05,721 - streaming - INFO - [chatcmpl-1503f2e8146f468993892ee257265847] Yielding [DONE] signal.
+2025-06-09 12:25:57,144 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 12:25:57,145 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 12:25:59,457 - __main__ - INFO - Driver quit successfully.
+2025-06-09 12:25:59,458 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 12:26:36,462 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:26:36,472 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:26:36,981 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:26:37,098 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:26:37,098 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:26:37,172 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:26:37,173 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:26:37,175 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:26:41,365 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:26:46,688 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:26:46,689 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:26:58,535 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:26:58,535 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:27:08,679 - __main__ - INFO - No on-site captcha detected. Main UI is ready.
+2025-06-09 12:27:08,680 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 12:27:08,680 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 12:27:08,776 - __main__ - INFO - [chatcmpl-41dd7f08cfdf4fbe82c61425ad970193] Received chat completion request: model='qwen no think', stream=True, md_convert=True
+2025-06-09 12:27:08,782 - streaming - INFO - [chatcmpl-41dd7f08cfdf4fbe82c61425ad970193] Starting streaming response generation for model 'qwen no think'.
+2025-06-09 12:27:08,782 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] Starting chat. Model: 'qwen no think', RawHTML: False, MarkdownMode: True.
+2025-06-09 12:27:08,783 - __main__ - INFO - Selecting model: qwen no think
+2025-06-09 12:27:09,091 - __main__ - INFO - Selected model: qwen no think
+2025-06-09 12:27:09,092 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] Sending prompt (first 50 chars): 'python pascals tree gen small concise code no comm...'
+2025-06-09 12:27:09,092 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 12:27:09,593 - __main__ - INFO - Prompt submitted.
+2025-06-09 12:27:09,593 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 12:27:09,719 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 12:27:09,719 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] Prompt sent. Streaming response...
+2025-06-09 12:27:13,322 - streaming - INFO - [StreamProc/Process] Starting stream in Markdown conversion mode.
+2025-06-09 12:27:29,116 - streaming - INFO - [StreamProc/PollStream] Content hasn't changed for 10.00s. Assuming stable.
+2025-06-09 12:27:29,116 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] Finished streaming response from browser.
+2025-06-09 12:27:29,117 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 12:27:29,117 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] Attempting to click 'New Chat' button.
+2025-06-09 12:27:29,217 - __main__ - INFO - [9a7a0c77-671d-451c-8839-28f19cc10692] 'New Chat' button clicked successfully.
+2025-06-09 12:27:29,218 - streaming - INFO - [chatcmpl-41dd7f08cfdf4fbe82c61425ad970193] Yielding final chunk. Total content length: 354 chars.
+2025-06-09 12:27:29,218 - streaming - INFO - [chatcmpl-41dd7f08cfdf4fbe82c61425ad970193] Yielding [DONE] signal.
+2025-06-09 12:40:32,330 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 12:40:32,331 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 12:40:34,681 - __main__ - INFO - Driver quit successfully.
+2025-06-09 12:40:34,681 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 12:40:42,096 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:40:42,104 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:40:42,595 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:40:42,628 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:40:42,629 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:40:42,654 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:40:42,654 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:40:42,656 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:40:45,740 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:40:51,056 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:40:51,056 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:40:51,062 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:40:51,062 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:41:03,731 - __main__ - INFO - No on-site captcha detected. Main UI is ready.
+2025-06-09 12:41:03,732 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 12:41:03,732 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 12:41:40,833 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:41:40,842 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:41:41,356 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:41:41,389 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:41:41,390 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:41:41,416 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:41:41,417 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:41:41,418 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:41:44,457 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:41:50,311 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:41:50,311 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:41:50,724 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:41:50,725 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:42:00,824 - __main__ - INFO - Textarea not ready or an on-site captcha indicator was found. Proceeding with AI solver.
+2025-06-09 12:42:00,824 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 12:42:01,009 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 12:42:01,009 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 12:42:01,010 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 12:42:03,591 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 12:42:03,744 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [721, 412, 755, 431], "label": "box"}
+]
+```
+2025-06-09 12:42:03,744 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [721, 412, 755, 431], 'label': 'box'}
+2025-06-09 12:42:07,526 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 12:42:07,527 - __main__ - INFO - Performing human-like page reload
+2025-06-09 12:42:07,527 - __main__ - INFO - Using FN+F5 key combination
+2025-06-09 12:42:09,853 - __main__ - INFO - Page reloaded after 1.42s delay
+2025-06-09 12:42:14,855 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 12:42:14,856 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 12:42:38,986 - __main__ - INFO - [chatcmpl-0e4becfc8b714621adc3a8e28fa6c832] Received chat completion request: model='Gemini 2.0 Flash', stream=True, md_convert=True
+2025-06-09 12:42:38,992 - streaming - INFO - [chatcmpl-0e4becfc8b714621adc3a8e28fa6c832] Starting streaming response generation for model 'Gemini 2.0 Flash'.
+2025-06-09 12:42:38,992 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] Starting chat. Model: 'Gemini 2.0 Flash', RawHTML: False, MarkdownMode: True.
+2025-06-09 12:42:38,992 - __main__ - INFO - Selecting model: Gemini 2.0 Flash
+2025-06-09 12:42:39,305 - __main__ - INFO - Selected model: Gemini 2.0 Flash
+2025-06-09 12:42:39,306 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] Sending prompt (first 50 chars): 'python pascals tree gen small concise code no comm...'
+2025-06-09 12:42:39,306 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 12:42:39,815 - __main__ - INFO - Prompt submitted.
+2025-06-09 12:42:39,815 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 12:42:39,917 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 12:42:39,917 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] Prompt sent. Streaming response...
+2025-06-09 12:42:52,374 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 12:42:52,378 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] Finished streaming response from browser.
+2025-06-09 12:42:52,378 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 12:42:52,378 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] Attempting to click 'New Chat' button.
+2025-06-09 12:42:52,462 - __main__ - INFO - [65ec22f0-f7c9-4c84-97ea-9d279cd1a901] 'New Chat' button clicked successfully.
+2025-06-09 12:42:52,463 - streaming - INFO - [chatcmpl-0e4becfc8b714621adc3a8e28fa6c832] Yielding final chunk. Total content length: 147 chars.
+2025-06-09 12:42:52,463 - streaming - INFO - [chatcmpl-0e4becfc8b714621adc3a8e28fa6c832] Yielding [DONE] signal.
+2025-06-09 12:43:26,774 - __main__ - INFO - [chatcmpl-3e2d2d8cded1427495834f07c4c5758b] Received chat completion request: model='Qwen No Think', stream=True, md_convert=True
+2025-06-09 12:43:26,775 - streaming - INFO - [chatcmpl-3e2d2d8cded1427495834f07c4c5758b] Starting streaming response generation for model 'Qwen No Think'.
+2025-06-09 12:43:26,775 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] Starting chat. Model: 'Qwen No Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 12:43:26,776 - __main__ - INFO - Selecting model: Qwen No Think
+2025-06-09 12:43:27,035 - __main__ - INFO - Selected model: Qwen No Think
+2025-06-09 12:43:27,036 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] Sending prompt (first 50 chars): 'python pascals tree gen long code no comments...'
+2025-06-09 12:43:27,036 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 12:43:27,342 - __main__ - INFO - Prompt submitted.
+2025-06-09 12:43:27,342 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 12:43:28,373 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 12:43:28,374 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] Prompt sent. Streaming response...
+2025-06-09 12:43:48,331 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 12:43:48,343 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] Finished streaming response from browser.
+2025-06-09 12:43:48,343 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 12:43:48,343 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] Attempting to click 'New Chat' button.
+2025-06-09 12:43:48,425 - __main__ - INFO - [2ea7dfd7-36df-44f6-b3c7-5b3b8e4c10b3] 'New Chat' button clicked successfully.
+2025-06-09 12:43:48,425 - streaming - INFO - [chatcmpl-3e2d2d8cded1427495834f07c4c5758b] Yielding final chunk. Total content length: 1323 chars.
+2025-06-09 12:43:48,425 - streaming - INFO - [chatcmpl-3e2d2d8cded1427495834f07c4c5758b] Yielding [DONE] signal.
+2025-06-09 12:45:57,240 - __main__ - INFO - Configuration loaded.
+2025-06-09 12:45:57,248 - __main__ - INFO - DriverManager instance created.
+2025-06-09 12:45:57,740 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 12:45:57,774 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 12:45:57,774 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 12:45:57,799 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 12:45:57,799 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 12:45:57,801 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 12:46:00,849 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 12:46:07,223 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 12:46:07,223 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 12:46:07,632 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 12:46:07,632 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 12:46:17,736 - __main__ - INFO - Textarea not ready or an on-site captcha indicator was found. Proceeding with AI solver.
+2025-06-09 12:46:17,736 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 12:46:17,898 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 12:46:17,899 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 12:46:17,899 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 12:46:20,718 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 12:46:20,809 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [728, 414, 747, 426], "label": "box"}
+]
+```
+2025-06-09 12:46:20,809 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [728, 414, 747, 426], 'label': 'box'}
+2025-06-09 12:46:24,589 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 12:46:24,590 - __main__ - INFO - Performing human-like page reload
+2025-06-09 12:46:24,591 - __main__ - INFO - Using FN+F5 key combination
+2025-06-09 12:46:26,398 - __main__ - INFO - Page reloaded after 0.90s delay
+2025-06-09 12:46:31,400 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 12:46:31,401 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 12:46:39,072 - __main__ - INFO - [chatcmpl-61168434d655486299ab964cfa879aaa] Received chat completion request: model='Qwen No Think', stream=True, md_convert=True
+2025-06-09 12:46:39,078 - streaming - INFO - [chatcmpl-61168434d655486299ab964cfa879aaa] Starting streaming response generation for model 'Qwen No Think'.
+2025-06-09 12:46:39,079 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] Starting chat. Model: 'Qwen No Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 12:46:39,079 - __main__ - INFO - Selecting model: Qwen No Think
+2025-06-09 12:46:39,440 - __main__ - INFO - Selected model: Qwen No Think
+2025-06-09 12:46:39,441 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] Sending prompt (first 50 chars): 'python pascals tree gen long code no comments...'
+2025-06-09 12:46:39,441 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 12:46:39,832 - __main__ - INFO - Prompt submitted.
+2025-06-09 12:46:39,833 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 12:46:39,925 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 12:46:39,926 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] Prompt sent. Streaming response...
+2025-06-09 12:46:43,010 - __main__ - ERROR - Streaming error: StreamConfig.__init__() got an unexpected keyword argument 'stream_raw_html'
+Traceback (most recent call last):
+  File "c:\Users\caree\Code\Lmarena\api.py", line 414, in _stream_response
+    stream_config = StreamConfig(
+        poll_interval=config.poll_interval,
+    ...<4 lines>...
+        convert_html_to_markdown=convert_html_to_markdown
+    )
+TypeError: StreamConfig.__init__() got an unexpected keyword argument 'stream_raw_html'
+2025-06-09 12:46:43,012 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] Finished streaming response from browser.
+2025-06-09 12:46:43,012 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 12:46:43,012 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] Attempting to click 'New Chat' button.
+2025-06-09 12:46:43,117 - __main__ - INFO - [876f2d65-bd15-445f-bf51-12d77336ca0c] 'New Chat' button clicked successfully.
+2025-06-09 13:13:16,829 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 13:13:16,830 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 13:13:19,250 - __main__ - INFO - Driver quit successfully.
+2025-06-09 13:13:19,251 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 13:13:22,817 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:13:22,825 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:13:23,338 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:13:23,372 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:13:23,372 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:13:23,398 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:13:23,399 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:13:23,400 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:13:26,459 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:13:31,687 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:13:31,687 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:13:42,971 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:13:42,971 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:13:53,072 - __main__ - INFO - No on-site captcha detected. Main UI is ready.
+2025-06-09 13:13:53,073 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:13:53,073 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:14:00,232 - __main__ - INFO - [chatcmpl-a016b7ca118c4d9b94482a2fc53638ca] Received chat completion request: model='Qwen No Think', stream=True, md_convert=True
+2025-06-09 13:14:00,238 - streaming - INFO - [chatcmpl-a016b7ca118c4d9b94482a2fc53638ca] Starting streaming response generation for model 'Qwen No Think'.
+2025-06-09 13:14:00,238 - __main__ - INFO - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Starting chat. Model: 'Qwen No Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:14:00,239 - __main__ - INFO - Selecting model: Qwen No Think
+2025-06-09 13:14:00,505 - __main__ - INFO - Selected model: Qwen No Think
+2025-06-09 13:14:00,506 - __main__ - INFO - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Sending prompt (first 50 chars): 'python pascals tree gen long code no comments...'
+2025-06-09 13:14:00,506 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:14:00,862 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:14:00,862 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:14:01,106 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:14:01,106 - __main__ - INFO - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Prompt sent. Streaming response...
+2025-06-09 13:17:05,718 - streaming - ERROR - [StreamProc/PollStream] Unexpected error polling: Message: no such window: target window already closed
+from unknown error: web view not found
+  (Session info: chrome=137.0.7151.69)
+Stacktrace:
+	GetHandleVerifier [0x0x7ff748e66f65+78965]
+	GetHandleVerifier [0x0x7ff748e66fc0+79056]
+	(No symbol) [0x0x7ff748bf9dda]
+	(No symbol) [0x0x7ff748bd20d1]
+	(No symbol) [0x0x7ff748c7ff4e]
+	(No symbol) [0x0x7ff748ca06cd]
+	(No symbol) [0x0x7ff748c78443]
+	(No symbol) [0x0x7ff748c41311]
+	(No symbol) [0x0x7ff748c420a3]
+	GetHandleVerifier [0x0x7ff74911e26d+2926461]
+	GetHandleVerifier [0x0x7ff749118993+2903715]
+	GetHandleVerifier [0x0x7ff749136aed+3026941]
+	GetHandleVerifier [0x0x7ff748e816fe+187406]
+	GetHandleVerifier [0x0x7ff748e896ef+220159]
+	GetHandleVerifier [0x0x7ff748e6faf4+114692]
+	GetHandleVerifier [0x0x7ff748e6fca9+115129]
+	GetHandleVerifier [0x0x7ff748e564d8+10728]
+	BaseThreadInitThunk [0x0x7ffd6f06e8d7+23]
+	RtlUserThreadStart [0x0x7ffd6fafc5dc+44]
+Traceback (most recent call last):
+  File "c:\Users\caree\Code\Lmarena\streaming.py", line 190, in _poll_element_content_stream
+    # Convert all finalized elements to markdown
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\support\wait.py", line 129, in until
+    value = method(self._driver)
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\support\expected_conditions.py", line 104, in _predicate
+    return driver.find_element(*locator)
+           ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\seleniumbase\core\sb_driver.py", line 27, in find_element
+    return self.driver.default_find_element(by=by, value=value)
+           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\remote\webdriver.py", line 914, in find_element
+    return self.execute(Command.FIND_ELEMENT, {"using": by, "value": value})["value"]
+           ~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\remote\webdriver.py", line 447, in execute
+    self.error_handler.check_response(response)
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\selenium\webdriver\remote\errorhandler.py", line 232, in check_response
+    raise exception_class(message, screen, stacktrace)
+selenium.common.exceptions.NoSuchWindowException: Message: no such window: target window already closed
+from unknown error: web view not found
+  (Session info: chrome=137.0.7151.69)
+Stacktrace:
+	GetHandleVerifier [0x0x7ff748e66f65+78965]
+	GetHandleVerifier [0x0x7ff748e66fc0+79056]
+	(No symbol) [0x0x7ff748bf9dda]
+	(No symbol) [0x0x7ff748bd20d1]
+	(No symbol) [0x0x7ff748c7ff4e]
+	(No symbol) [0x0x7ff748ca06cd]
+	(No symbol) [0x0x7ff748c78443]
+	(No symbol) [0x0x7ff748c41311]
+	(No symbol) [0x0x7ff748c420a3]
+	GetHandleVerifier [0x0x7ff74911e26d+2926461]
+	GetHandleVerifier [0x0x7ff749118993+2903715]
+	GetHandleVerifier [0x0x7ff749136aed+3026941]
+	GetHandleVerifier [0x0x7ff748e816fe+187406]
+	GetHandleVerifier [0x0x7ff748e896ef+220159]
+	GetHandleVerifier [0x0x7ff748e6faf4+114692]
+	GetHandleVerifier [0x0x7ff748e6fca9+115129]
+	GetHandleVerifier [0x0x7ff748e564d8+10728]
+	BaseThreadInitThunk [0x0x7ffd6f06e8d7+23]
+	RtlUserThreadStart [0x0x7ffd6fafc5dc+44]
+
+2025-06-09 13:17:05,797 - __main__ - INFO - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Finished streaming response from browser.
+2025-06-09 13:17:05,797 - __main__ - INFO - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:17:05,798 - __main__ - INFO - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Attempting to click 'New Chat' button.
+2025-06-09 13:17:12,857 - __main__ - ERROR - [0e1927b9-8699-4b08-9338-c2962ebdc6d9] Error clicking 'New Chat' during cleanup: Message: 
+ Element {//a[contains(@class, 'whitespace-nowrap') and .//h2[contains(text(), 'New Chat')]]} was not present after 7 seconds!
+Traceback (most recent call last):
+  File "c:\Users\caree\Code\Lmarena\api.py", line 384, in send_message_and_stream_response
+    await ChatHandler._click_new_chat(driver, request_id)
+  File "c:\Users\caree\Code\Lmarena\api.py", line 442, in _click_new_chat
+    yield item
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\concurrent\futures\thread.py", line 59, in run
+    result = self.fn(*self.args, **self.kwargs)
+  File "c:\Users\caree\Code\Lmarena\api.py", line 442, in <lambda>
+    yield item
+    
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\seleniumbase\core\sb_driver.py", line 82, in click
+    page_actions.click(self.driver, *args, **kwargs)
+    ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\seleniumbase\fixtures\page_actions.py", line 1595, in click
+    element = wait_for_element_clickable(
+        driver, selector, by=by, timeout=timeout
+    )
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\seleniumbase\fixtures\page_actions.py", line 910, in wait_for_element_clickable
+    timeout_exception(NoSuchElementException, message)
+    ~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\caree\AppData\Local\Programs\Python\Python313\Lib\site-packages\seleniumbase\fixtures\page_actions.py", line 267, in timeout_exception
+    raise exc(msg)
+seleniumbase.common.exceptions.NoSuchElementException: Message: 
+ Element {//a[contains(@class, 'whitespace-nowrap') and .//h2[contains(text(), 'New Chat')]]} was not present after 7 seconds!
+
+2025-06-09 13:17:16,355 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:17:16,363 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:17:16,867 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:17:16,902 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:17:16,902 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:17:16,929 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:17:16,930 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:17:16,931 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:17:19,968 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:17:25,172 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:17:25,172 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:17:36,533 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:17:36,534 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:17:46,626 - __main__ - INFO - No on-site captcha detected. Main UI is ready.
+2025-06-09 13:17:46,627 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:17:46,627 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:17:47,719 - __main__ - INFO - [chatcmpl-dad296131df54a5d9fc92ff2820fc08f] Received chat completion request: model='Qwen No Think', stream=True, md_convert=True
+2025-06-09 13:17:47,725 - streaming - INFO - [chatcmpl-dad296131df54a5d9fc92ff2820fc08f] Starting streaming response generation for model 'Qwen No Think'.
+2025-06-09 13:17:47,725 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] Starting chat. Model: 'Qwen No Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:17:47,725 - __main__ - INFO - Selecting model: Qwen No Think
+2025-06-09 13:17:48,003 - __main__ - INFO - Selected model: Qwen No Think
+2025-06-09 13:17:48,004 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] Sending prompt (first 50 chars): 'python pascals tree gen long code no comments...'
+2025-06-09 13:17:48,004 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:17:48,357 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:17:48,357 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:17:48,587 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:17:48,588 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] Prompt sent. Streaming response...
+2025-06-09 13:18:11,478 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 13:18:11,489 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] Finished streaming response from browser.
+2025-06-09 13:18:11,489 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:18:11,490 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] Attempting to click 'New Chat' button.
+2025-06-09 13:18:11,577 - __main__ - INFO - [8382e611-556c-4cc7-a67a-2efc5d9f5ad3] 'New Chat' button clicked successfully.
+2025-06-09 13:18:11,578 - streaming - INFO - [chatcmpl-dad296131df54a5d9fc92ff2820fc08f] Yielding final chunk. Total content length: 1566 chars.
+2025-06-09 13:18:11,578 - streaming - INFO - [chatcmpl-dad296131df54a5d9fc92ff2820fc08f] Yielding [DONE] signal.
+2025-06-09 13:21:08,343 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:21:08,351 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:21:08,842 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:21:08,875 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:21:08,876 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:21:08,902 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:21:08,902 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:21:08,904 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:21:11,994 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:21:17,315 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:21:17,316 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:21:17,324 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:21:17,325 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:21:22,605 - __main__ - INFO - Chat input textarea not interactable. Proceeding with AI captcha solver.
+2025-06-09 13:21:22,605 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 13:21:22,740 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 13:21:22,740 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 13:21:22,741 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 13:21:25,207 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 13:21:25,465 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [578, 164, 614, 186], "label": "box"}
+]
+```
+2025-06-09 13:21:25,466 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [578, 164, 614, 186], 'label': 'box'}
+2025-06-09 13:21:29,140 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 13:21:29,140 - __main__ - INFO - Performing human-like page reload
+2025-06-09 13:21:29,141 - __main__ - INFO - Using FN+F5 key combination
+2025-06-09 13:21:30,930 - __main__ - INFO - Page reloaded after 0.88s delay
+2025-06-09 13:21:35,931 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:21:35,931 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:21:49,966 - __main__ - INFO - [chatcmpl-d6223c77e0534551872ec565df4666fa] Received chat completion request: model='Qwen No Think', stream=True, md_convert=True
+2025-06-09 13:21:49,972 - streaming - INFO - [chatcmpl-d6223c77e0534551872ec565df4666fa] Starting streaming response generation for model 'Qwen No Think'.
+2025-06-09 13:21:49,972 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] Starting chat. Model: 'Qwen No Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:21:49,972 - __main__ - INFO - Selecting model: Qwen No Think
+2025-06-09 13:21:50,279 - __main__ - INFO - Selected model: Qwen No Think
+2025-06-09 13:21:50,279 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] Sending prompt (first 50 chars): 'python pascals tree gen long code no comments...'
+2025-06-09 13:21:50,280 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:21:50,640 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:21:50,641 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:21:50,772 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:21:50,772 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] Prompt sent. Streaming response...
+2025-06-09 13:22:11,608 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 13:22:11,616 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] Finished streaming response from browser.
+2025-06-09 13:22:11,616 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:22:11,617 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] Attempting to click 'New Chat' button.
+2025-06-09 13:22:11,701 - __main__ - INFO - [ffe50244-a76d-4a41-b938-5f943206d84f] 'New Chat' button clicked successfully.
+2025-06-09 13:22:11,701 - streaming - INFO - [chatcmpl-d6223c77e0534551872ec565df4666fa] Yielding final chunk. Total content length: 1249 chars.
+2025-06-09 13:22:11,701 - streaming - INFO - [chatcmpl-d6223c77e0534551872ec565df4666fa] Yielding [DONE] signal.
+2025-06-09 13:22:51,763 - __main__ - INFO - [chatcmpl-906b9b8c6d38464f8416cf58c56947bc] Received chat completion request: model='Claude Opus 4 Thinking', stream=True, md_convert=True
+2025-06-09 13:22:51,764 - streaming - INFO - [chatcmpl-906b9b8c6d38464f8416cf58c56947bc] Starting streaming response generation for model 'Claude Opus 4 Thinking'.
+2025-06-09 13:22:51,765 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] Starting chat. Model: 'Claude Opus 4 Thinking', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:22:51,765 - __main__ - INFO - Selecting model: Claude Opus 4 Thinking
+2025-06-09 13:22:52,143 - __main__ - INFO - Selected model: Claude Opus 4 Thinking
+2025-06-09 13:22:52,143 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] Sending prompt (first 50 chars): 'python pascals tree gen long code no comments...'
+2025-06-09 13:22:52,144 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:22:52,487 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:22:52,487 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:22:53,513 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:22:53,513 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] Prompt sent. Streaming response...
+2025-06-09 13:24:08,306 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 13:24:08,404 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] Finished streaming response from browser.
+2025-06-09 13:24:08,404 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:24:08,404 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] Attempting to click 'New Chat' button.
+2025-06-09 13:24:09,131 - __main__ - INFO - [b9ae0a31-1028-443b-a3dc-aa74a12fedef] 'New Chat' button clicked successfully.
+2025-06-09 13:24:09,132 - streaming - INFO - [chatcmpl-906b9b8c6d38464f8416cf58c56947bc] Yielding final chunk. Total content length: 12889 chars.
+2025-06-09 13:24:09,132 - streaming - INFO - [chatcmpl-906b9b8c6d38464f8416cf58c56947bc] Yielding [DONE] signal.
+2025-06-09 13:24:37,914 - __main__ - INFO - [chatcmpl-8397b786dfc94d6fa186bf302fdb5091] Received chat completion request: model='Claude Opus 4 Thinking', stream=True, md_convert=True
+2025-06-09 13:24:37,915 - streaming - INFO - [chatcmpl-8397b786dfc94d6fa186bf302fdb5091] Starting streaming response generation for model 'Claude Opus 4 Thinking'.
+2025-06-09 13:24:37,916 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] Starting chat. Model: 'Claude Opus 4 Thinking', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:24:37,916 - __main__ - INFO - Selecting model: Claude Opus 4 Thinking
+2025-06-09 13:24:38,290 - __main__ - INFO - Selected model: Claude Opus 4 Thinking
+2025-06-09 13:24:38,291 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] Sending prompt (first 50 chars): 'python pascals tree gen long code explain everythi...'
+2025-06-09 13:24:38,291 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:24:38,870 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:24:38,871 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:24:39,905 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:24:39,906 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] Prompt sent. Streaming response...
+2025-06-09 13:27:21,691 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 13:27:22,031 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] Finished streaming response from browser.
+2025-06-09 13:27:22,031 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:27:22,031 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] Attempting to click 'New Chat' button.
+2025-06-09 13:27:22,120 - __main__ - INFO - [ddd1b72b-d54f-46d0-a3c9-32760b378dce] 'New Chat' button clicked successfully.
+2025-06-09 13:27:22,120 - streaming - INFO - [chatcmpl-8397b786dfc94d6fa186bf302fdb5091] Yielding final chunk. Total content length: 26526 chars.
+2025-06-09 13:27:22,121 - streaming - INFO - [chatcmpl-8397b786dfc94d6fa186bf302fdb5091] Yielding [DONE] signal.
+2025-06-09 13:29:20,701 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 13:29:20,702 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 13:29:23,130 - __main__ - INFO - Driver quit successfully.
+2025-06-09 13:29:23,130 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 13:29:42,779 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:29:42,787 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:29:43,278 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:29:43,312 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:29:43,312 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:29:43,338 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:29:43,339 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:29:43,340 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:29:46,450 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:29:51,744 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:29:51,745 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:30:03,036 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:30:03,036 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:30:13,135 - __main__ - INFO - No on-site captcha detected. Main UI is ready.
+2025-06-09 13:30:13,136 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:30:13,136 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:30:42,946 - __main__ - INFO - [chatcmpl-0977bf5aff9b43f3889a3eee2ff0c0c8] Received chat completion request: model='Qwen no Think', stream=True, md_convert=True
+2025-06-09 13:30:42,953 - streaming - INFO - [chatcmpl-0977bf5aff9b43f3889a3eee2ff0c0c8] Starting streaming response for model 'Qwen no Think'
+2025-06-09 13:30:42,953 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] Starting chat. Model: 'Qwen no Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:30:42,953 - __main__ - INFO - Selecting model: Qwen no Think
+2025-06-09 13:30:43,303 - __main__ - INFO - Selected model: Qwen no Think
+2025-06-09 13:30:43,304 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] Sending prompt (first 50 chars): 'python pascals tree gen long code explain everythi...'
+2025-06-09 13:30:43,304 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:30:43,961 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:30:43,962 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:30:44,084 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:30:44,084 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] Prompt sent. Streaming response...
+2025-06-09 13:30:47,172 - streaming - INFO - [StreamProc/Poll] Starting content polling
+2025-06-09 13:31:42,729 - streaming - INFO - [StreamProc/Poll] Content stable for 11.1s, ending stream
+2025-06-09 13:31:42,763 - streaming - INFO - Stream metrics: 1253 polls, 539 changes, 29,442,690 bytes in 55.59s
+2025-06-09 13:31:42,763 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] Finished streaming response from browser.
+2025-06-09 13:31:42,763 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:31:42,764 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] Attempting to click 'New Chat' button.
+2025-06-09 13:31:42,872 - __main__ - INFO - [8dca5736-454b-4a53-afc7-9a1356f5609a] 'New Chat' button clicked successfully.
+2025-06-09 13:31:42,873 - streaming - INFO - [chatcmpl-0977bf5aff9b43f3889a3eee2ff0c0c8] Streaming complete. Total content: 360 chars
+2025-06-09 13:33:24,447 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 13:33:24,447 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 13:33:26,769 - __main__ - INFO - Driver quit successfully.
+2025-06-09 13:33:26,769 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 13:34:01,581 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:34:01,589 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:34:02,081 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:34:02,114 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:34:02,115 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:34:02,141 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:34:02,141 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:34:02,143 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:34:05,208 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:34:10,548 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:34:10,549 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:34:10,922 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:34:10,922 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:34:21,031 - __main__ - INFO - Textarea not ready or an on-site captcha indicator was found. Proceeding with AI solver.
+2025-06-09 13:34:21,031 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 13:34:21,207 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 13:34:21,208 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 13:34:21,208 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 13:34:23,882 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 13:34:24,045 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [720, 412, 757, 431], "label": "box"}
+]
+```
+2025-06-09 13:34:24,045 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [720, 412, 757, 431], 'label': 'box'}
+2025-06-09 13:34:27,822 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 13:34:27,823 - __main__ - INFO - Performing human-like page reload
+2025-06-09 13:34:27,823 - __main__ - INFO - Using F5 key
+2025-06-09 13:34:28,965 - __main__ - INFO - Page reloaded after 1.04s delay
+2025-06-09 13:34:33,967 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:34:33,968 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:34:42,463 - __main__ - INFO - [chatcmpl-7a355706384e4df3a77f1c6dc66ca4be] Received chat completion request: model='Qwen no Think', stream=True, md_convert=True
+2025-06-09 13:34:42,470 - streaming - INFO - [chatcmpl-7a355706384e4df3a77f1c6dc66ca4be] Starting streaming response for model 'Qwen no Think'
+2025-06-09 13:34:42,470 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] Starting chat. Model: 'Qwen no Think', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:34:42,471 - __main__ - INFO - Selecting model: Qwen no Think
+2025-06-09 13:34:42,761 - __main__ - INFO - Selected model: Qwen no Think
+2025-06-09 13:34:42,761 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] Sending prompt (first 50 chars): 'bionomial thoerem calc in python concise code but ...'
+2025-06-09 13:34:42,762 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:34:43,244 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:34:43,244 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:34:43,345 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:34:43,345 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] Prompt sent. Streaming response...
+2025-06-09 13:34:45,905 - __main__ - ERROR - Streaming error: StreamConfig.__init__() got an unexpected keyword argument 'stabilization_timeout'
+Traceback (most recent call last):
+  File "c:\Users\caree\Code\Lmarena\api.py", line 414, in _stream_response
+    stream_config = StreamConfig(
+        poll_interval=config.poll_interval,
+    ...<4 lines>...
+        convert_html_to_markdown=convert_html_to_markdown
+    )
+TypeError: StreamConfig.__init__() got an unexpected keyword argument 'stabilization_timeout'
+2025-06-09 13:34:45,907 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] Finished streaming response from browser.
+2025-06-09 13:34:45,907 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:34:45,907 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] Attempting to click 'New Chat' button.
+2025-06-09 13:34:46,048 - __main__ - INFO - [fa42552d-73dc-4eee-bc0f-55a4ce19a39a] 'New Chat' button clicked successfully.
+2025-06-09 13:34:46,049 - streaming - INFO - [chatcmpl-7a355706384e4df3a77f1c6dc66ca4be] Streaming complete. Sent 1 chunks, total: 91 chars
+2025-06-09 13:36:40,674 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:36:40,682 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:36:41,181 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:36:41,214 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:36:41,214 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:36:41,240 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:36:41,241 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:36:41,243 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:36:44,311 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:36:50,037 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:36:50,037 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:36:50,534 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:36:50,534 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:37:00,639 - __main__ - INFO - Textarea not ready or an on-site captcha indicator was found. Proceeding with AI solver.
+2025-06-09 13:37:00,639 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 13:37:00,795 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 13:37:00,796 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 13:37:00,796 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 13:37:03,575 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 13:37:03,688 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [722, 412, 754, 431], "label": "box"}
+]
+```
+2025-06-09 13:37:03,689 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [722, 412, 754, 431], 'label': 'box'}
+2025-06-09 13:37:07,369 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 13:37:07,370 - __main__ - INFO - Performing human-like page reload
+2025-06-09 13:37:07,370 - __main__ - INFO - Using FN+F5 key combination
+2025-06-09 13:37:08,832 - __main__ - INFO - Page reloaded after 0.56s delay
+2025-06-09 13:37:13,834 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:37:13,834 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:37:17,850 - __main__ - INFO - [chatcmpl-5b3f2aabac7849ddb66938c955880bf8] Received chat completion request: model='Gemini 2.0', stream=True, md_convert=True
+2025-06-09 13:37:17,857 - streaming - INFO - [chatcmpl-5b3f2aabac7849ddb66938c955880bf8] Starting streaming response for model 'Gemini 2.0'
+2025-06-09 13:37:17,857 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] Starting chat. Model: 'Gemini 2.0', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:37:17,857 - __main__ - INFO - Selecting model: Gemini 2.0
+2025-06-09 13:37:18,193 - __main__ - INFO - Selected model: Gemini 2.0
+2025-06-09 13:37:18,194 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] Sending prompt (first 50 chars): 'bionomial thoerem calc in python concise code but ...'
+2025-06-09 13:37:18,194 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:37:18,784 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:37:18,785 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:37:18,884 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:37:18,884 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] Prompt sent. Streaming response...
+2025-06-09 13:37:29,096 - streaming - INFO - [StreamProc/Poll] Starting content polling
+2025-06-09 13:37:43,597 - streaming - INFO - [StreamProc/Poll] Content stable for 10.0s, ending stream
+2025-06-09 13:37:43,598 - streaming - INFO - [StreamProc/Poll] Polling ended after 14.5s
+2025-06-09 13:37:43,598 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] Finished streaming response from browser.
+2025-06-09 13:37:43,599 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:37:43,599 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] Attempting to click 'New Chat' button.
+2025-06-09 13:37:43,686 - __main__ - INFO - [7060fd0f-7d80-4957-a475-8cd2ab15676c] 'New Chat' button clicked successfully.
+2025-06-09 13:37:43,687 - streaming - INFO - [chatcmpl-5b3f2aabac7849ddb66938c955880bf8] Streaming complete. Sent 26 chunks, total: 30702 chars
+2025-06-09 13:37:57,826 - __main__ - INFO - Application shutdown sequence initiated.
+2025-06-09 13:37:57,827 - __main__ - INFO - Cleaning up and quitting Selenium driver...
+2025-06-09 13:38:00,251 - __main__ - INFO - Driver quit successfully.
+2025-06-09 13:38:00,252 - __main__ - INFO - Application shutdown sequence completed.
+2025-06-09 13:38:05,462 - __main__ - INFO - Configuration loaded.
+2025-06-09 13:38:05,476 - __main__ - INFO - DriverManager instance created.
+2025-06-09 13:38:05,982 - __main__ - INFO - Gemini client initialized successfully.
+2025-06-09 13:38:06,014 - __main__ - INFO - GEMINI_API_KEY is set.
+2025-06-09 13:38:06,015 - __main__ - INFO - Starting Uvicorn server on 0.0.0.0:8000.
+2025-06-09 13:38:06,040 - __main__ - INFO - Application startup sequence initiated.
+2025-06-09 13:38:06,041 - __main__ - INFO - Initializing Selenium driver...
+2025-06-09 13:38:06,042 - __main__ - INFO - Executing synchronous driver initialization and enhanced readiness check.
+2025-06-09 13:38:09,109 - __main__ - INFO - Driver instantiated. Opening URL...
+2025-06-09 13:38:16,487 - __main__ - INFO - URL 'https://beta.lmarena.ai/?mode=direct' opened.
+2025-06-09 13:38:16,488 - __main__ - INFO - Attempting to solve initial (Cloudflare-style) captcha with uc_gui_click_captcha()...
+2025-06-09 13:38:17,034 - __main__ - INFO - uc_gui_click_captcha() completed. Main site should be loading now.
+2025-06-09 13:38:17,034 - __main__ - INFO - Checking for on-site ('Verify Human') captcha...
+2025-06-09 13:38:27,140 - __main__ - INFO - Textarea not ready or an on-site captcha indicator was found. Proceeding with AI solver.
+2025-06-09 13:38:27,141 - __main__ - INFO - Starting visual AI check for on-site captcha.
+2025-06-09 13:38:27,292 - __main__ - INFO - Sending screenshot to Gemini API for analysis.
+2025-06-09 13:38:27,293 - google_genai.models - INFO - AFC is enabled with max remote calls: 10.
+2025-06-09 13:38:27,294 - google_genai.models - INFO - AFC remote call 1 is done.
+2025-06-09 13:38:30,360 - httpx - INFO - HTTP Request: POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse "HTTP/1.1 200 OK"
+2025-06-09 13:38:30,419 - __main__ - INFO - Received Gemini response for on-site captcha check: ```json
+[
+  {"box_2d": [715, 412, 758, 432], "label": "box"}
+]
+```
+2025-06-09 13:38:30,419 - __main__ - INFO - On-site captcha checkbox found via Gemini. Clicking coordinates: {'box_2d': [715, 412, 758, 432], 'label': 'box'}
+2025-06-09 13:38:34,201 - __main__ - INFO - Click performed. Now reloading page as requested for post-AI solve.
+2025-06-09 13:38:34,202 - __main__ - INFO - Performing human-like page reload
+2025-06-09 13:38:34,202 - __main__ - INFO - Using FN+F5 key combination
+2025-06-09 13:38:36,047 - __main__ - INFO - Page reloaded after 0.94s delay
+2025-06-09 13:38:41,049 - __main__ - INFO - Selenium driver initialization process completed successfully.
+2025-06-09 13:38:41,050 - __main__ - INFO - Application startup sequence completed successfully.
+2025-06-09 13:38:44,622 - __main__ - INFO - [chatcmpl-28b698e36b09432383823c19da3c0335] Received chat completion request: model='Gemini 2.0 Flash', stream=True, md_convert=True
+2025-06-09 13:38:44,629 - streaming - INFO - [chatcmpl-28b698e36b09432383823c19da3c0335] Starting streaming response generation for model 'Gemini 2.0 Flash'.
+2025-06-09 13:38:44,629 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] Starting chat. Model: 'Gemini 2.0 Flash', RawHTML: False, MarkdownMode: True.
+2025-06-09 13:38:44,630 - __main__ - INFO - Selecting model: Gemini 2.0 Flash
+2025-06-09 13:38:44,985 - __main__ - INFO - Selected model: Gemini 2.0 Flash
+2025-06-09 13:38:44,986 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] Sending prompt (first 50 chars): 'bionomial thoerem calc in python concise code but ...'
+2025-06-09 13:38:44,986 - __main__ - INFO - Typing prompt into textarea.
+2025-06-09 13:38:45,522 - __main__ - INFO - Prompt submitted.
+2025-06-09 13:38:45,523 - __main__ - INFO - Checking for 'Agree' button in dialog.
+2025-06-09 13:38:45,612 - __main__ - INFO - 'Agree' button not visible, skipping.
+2025-06-09 13:38:45,612 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] Prompt sent. Streaming response...
+2025-06-09 13:39:06,675 - streaming - INFO - [StreamProc/PollStream] Content stable for 10.00s. Ending poll.
+2025-06-09 13:39:06,688 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] Finished streaming response from browser.
+2025-06-09 13:39:06,689 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] Cleaning up chat session by clicking 'New Chat'.
+2025-06-09 13:39:06,689 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] Attempting to click 'New Chat' button.
+2025-06-09 13:39:06,765 - __main__ - INFO - [0c17e458-0e06-47bf-ba50-a1bc3da3d518] 'New Chat' button clicked successfully.
+2025-06-09 13:39:06,766 - streaming - INFO - [chatcmpl-28b698e36b09432383823c19da3c0335] Yielding final chunk. Total content length: 3937 chars.
+2025-06-09 13:39:06,766 - streaming - INFO - [chatcmpl-28b698e36b09432383823c19da3c0335] Yielding [DONE] signal.

requirements.txt

@@ -10,4 +10,5 @@ starlette
 openai
 pyvirtualdisplay
 mss
+beautifulsoup4
 PyAutoGUI

sdfhsdf.py

@@ -0,0 +1,676 @@
+"""
+Pascal's Tree Generator - A Comprehensive Implementation
+======================================================
+
+This module implements multiple interpretations of Pascal's tree:
+1. Binary tree where each node contains Pascal's triangle values
+2. Tree representation showing the recursive nature of Pascal's triangle
+3. Path-based tree showing how Pascal values are constructed
+"""
+
+import math
+from typing import List, Optional, Tuple, Dict, Any
+from collections import deque
+import matplotlib.pyplot as plt
+import networkx as nx
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class TreeNode:
+    """
+    Represents a node in Pascal's tree.
+
+    Attributes:
+        value: The numeric value at this node (from Pascal's triangle)
+        row: The row in Pascal's triangle (0-indexed)
+        col: The column in Pascal's triangle (0-indexed)
+        left: Left child node
+        right: Right child node
+        parent: Parent node reference
+        coefficient: The binomial coefficient C(row, col)
+    """
+    value: int
+    row: int
+    col: int
+    left: Optional['TreeNode'] = None
+    right: Optional['TreeNode'] = None
+    parent: Optional['TreeNode'] = None
+    coefficient: Optional[int] = None
+
+    def __post_init__(self):
+        # Calculate binomial coefficient if not provided
+        if self.coefficient is None:
+            self.coefficient = self._calculate_binomial_coefficient()
+
+    def _calculate_binomial_coefficient(self) -> int:
+        """
+        Calculate C(n, k) = n! / (k! * (n-k)!)
+        Using the multiplicative formula for efficiency
+        """
+        if self.col > self.row or self.col < 0:
+            return 0
+        if self.col == 0 or self.col == self.row:
+            return 1
+
+        # Use symmetry property: C(n, k) = C(n, n-k)
+        k = min(self.col, self.row - self.col)
+
+        result = 1
+        for i in range(k):
+            result = result * (self.row - i) // (i + 1)
+
+        return result
+
+
+class PascalTreeGenerator:
+    """
+    Main class for generating various forms of Pascal's tree.
+
+    This class implements multiple algorithms for constructing Pascal's tree,
+    each highlighting different mathematical properties and relationships.
+    """
+
+    def __init__(self):
+        self.root = None
+        self.nodes_by_position = {}  # (row, col) -> TreeNode
+        self.level_nodes = {}  # row -> List[TreeNode]
+
+    def generate_recursive_tree(self, max_depth: int) -> TreeNode:
+        """
+        Generate Pascal's tree using recursive construction.
+
+        This method creates a binary tree where:
+        - Each node (n, k) has value C(n, k)
+        - Left child is (n+1, k)
+        - Right child is (n+1, k+1)
+
+        This represents the recursive property:
+        C(n+1, k) + C(n+1, k+1) = C(n+2, k+1)
+
+        Args:
+            max_depth: Maximum depth of the tree
+
+        Returns:
+            Root node of the tree
+        """
+        self.root = self._build_recursive_node(0, 0, max_depth)
+        return self.root
+
+    def _build_recursive_node(self, row: int, col: int, max_depth: int,
+                             parent: Optional[TreeNode] = None) -> Optional[TreeNode]:
+        """
+        Recursively build tree nodes.
+
+        The mathematical insight here is that Pascal's triangle can be
+        constructed by the recurrence relation:
+        C(n, k) = C(n-1, k-1) + C(n-1, k)
+
+        We're building the tree in the forward direction, showing how
+        each value contributes to values in subsequent rows.
+        """
+        if row > max_depth or col > row or col < 0:
+            return None
+
+        # Create node with binomial coefficient value
+        node = TreeNode(
+            value=math.comb(row, col),  # Python 3.8+ built-in
+            row=row,
+            col=col,
+            parent=parent
+        )
+
+        # Store node reference for later access
+        self.nodes_by_position[(row, col)] = node
+
+        if row not in self.level_nodes:
+            self.level_nodes[row] = []
+        self.level_nodes[row].append(node)
+
+        # Build children representing contributions to next row
+        node.left = self._build_recursive_node(row + 1, col, max_depth, node)
+        node.right = self._build_recursive_node(row + 1, col + 1, max_depth, node)
+
+        return node
+
+    def generate_path_sum_tree(self, max_depth: int) -> TreeNode:
+        """
+        Generate a tree where paths from root represent the construction
+        of Pascal's triangle values through path counting.
+
+        Mathematical principle: C(n, k) equals the number of paths from
+        (0, 0) to (n, k) moving only right or down in a grid.
+
+        In tree form:
+        - Left branch represents "choosing" an element
+        - Right branch represents "not choosing" an element
+        """
+        self.root = TreeNode(value=1, row=0, col=0)
+        self._build_path_tree(self.root, max_depth)
+        return self.root
+
+    def _build_path_tree(self, node: TreeNode, remaining_depth: int):
+        """
+        Build tree based on path counting interpretation.
+
+        Each path from root to a node at depth n with k left turns
+        represents one of the C(n, k) ways to choose k items from n items.
+        """
+        if remaining_depth <= 0:
+            return
+
+        # Left child: "choose" (increment both row and col)
+        node.left = TreeNode(
+            value=node.value,  # Path count remains same along each path
+            row=node.row + 1,
+            col=node.col + 1,
+            parent=node
+        )
+
+        # Right child: "don't choose" (increment only row)
+        node.right = TreeNode(
+            value=node.value,
+            row=node.row + 1,
+            col=node.col,
+            parent=node
+        )
+
+        # Recursively build subtrees
+        self._build_path_tree(node.left, remaining_depth - 1)
+        self._build_path_tree(node.right, remaining_depth - 1)
+
+    def generate_sierpinski_tree(self, max_depth: int) -> TreeNode:
+        """
+        Generate Pascal's tree with Sierpinski triangle properties.
+
+        Mathematical insight: When Pascal's triangle values are taken
+        modulo 2, the resulting pattern is the Sierpinski triangle.
+
+        This tree structure highlights the fractal nature of Pascal's
+        triangle and its connection to cellular automata.
+        """
+        self.root = TreeNode(value=1, row=0, col=0)
+        self._build_sierpinski_node(self.root, max_depth)
+        return self.root
+
+    def _build_sierpinski_node(self, node: TreeNode, remaining_depth: int):
+        """
+        Build tree with Sierpinski triangle properties.
+
+        Odd values in Pascal's triangle form the Sierpinski triangle
+        pattern. This is related to Lucas' theorem about binomial
+        coefficients modulo primes.
+        """
+        if remaining_depth <= 0:
+            return
+
+        # Calculate children values using the recurrence relation
+        left_val = self._get_pascal_value(node.row + 1, node.col)
+        right_val = self._get_pascal_value(node.row + 1, node.col + 1)
+
+        # Create children with modulo 2 coloring for Sierpinski
+        if left_val > 0:  # Valid position in triangle
+            node.left = TreeNode(
+                value=left_val,
+                row=node.row + 1,
+                col=node.col,
+                parent=node
+            )
+            node.left.sierpinski_bit = left_val % 2
+            self._build_sierpinski_node(node.left, remaining_depth - 1)
+
+        if right_val > 0:  # Valid position in triangle
+            node.right = TreeNode(
+                value=right_val,
+                row=node.row + 1,
+                col=node.col + 1,
+                parent=node
+            )
+            node.right.sierpinski_bit = right_val % 2
+            self._build_sierpinski_node(node.right, remaining_depth - 1)
+
+    def _get_pascal_value(self, row: int, col: int) -> int:
+        """
+        Get Pascal's triangle value at (row, col).
+
+        Uses the efficient multiplicative formula rather than
+        factorial calculation for better performance.
+        """
+        if col > row or col < 0:
+            return 0
+        if col == 0 or col == row:
+            return 1
+
+        # Use dynamic programming if we've already calculated it
+        if (row, col) in self.nodes_by_position:
+            return self.nodes_by_position[(row, col)].value
+
+        # Calculate using the multiplicative formula
+        k = min(col, row - col)  # Use symmetry
+        result = 1
+        for i in range(k):
+            result = result * (row - i) // (i + 1)
+
+        return result
+
+    def calculate_tree_properties(self, root: TreeNode) -> Dict[str, Any]:
+        """
+        Calculate various mathematical properties of the generated tree.
+
+        This includes:
+        - Sum of values at each level (should equal 2^n)
+        - Maximum value at each level
+        - Number of odd values (related to Sierpinski)
+        - Tree balance metrics
+        """
+        properties = {
+            'level_sums': {},
+            'level_max_values': {},
+            'odd_count_by_level': {},
+            'total_nodes': 0,
+            'leaf_nodes': 0,
+            'internal_nodes': 0,
+            'max_depth': 0,
+            'perfectly_balanced': True
+        }
+
+        # BFS traversal to calculate properties
+        queue = deque([(root, 0)])
+        level_nodes_count = {}
+
+        while queue:
+            node, depth = queue.popleft()
+            properties['total_nodes'] += 1
+            properties['max_depth'] = max(properties['max_depth'], depth)
+
+            # Update level-based statistics
+            if depth not in properties['level_sums']:
+                properties['level_sums'][depth] = 0
+                properties['level_max_values'][depth] = 0
+                properties['odd_count_by_level'][depth] = 0
+                level_nodes_count[depth] = 0
+
+            properties['level_sums'][depth] += node.value
+            properties['level_max_values'][depth] = max(
+                properties['level_max_values'][depth],
+                node.value
+            )
+
+            if node.value % 2 == 1:
+                properties['odd_count_by_level'][depth] += 1
+
+            level_nodes_count[depth] += 1
+
+            # Check if leaf or internal node
+            if node.left is None and node.right is None:
+                properties['leaf_nodes'] += 1
+            else:
+                properties['internal_nodes'] += 1
+                if node.left:
+                    queue.append((node.left, depth + 1))
+                if node.right:
+                    queue.append((node.right, depth + 1))
+
+        # Verify mathematical properties
+        properties['level_sum_verification'] = {}
+        for level, sum_val in properties['level_sums'].items():
+            expected = 2 ** level  # Sum of row n in Pascal's triangle
+            properties['level_sum_verification'][level] = {
+                'actual': sum_val,
+                'expected': expected,
+                'correct': sum_val == expected
+            }
+
+        # Check if tree is perfectly balanced
+        for level in range(properties['max_depth']):
+            expected_nodes = 2 ** level
+            if level_nodes_count[level] != expected_nodes:
+                properties['perfectly_balanced'] = False
+                break
+
+        return properties
+
+    def visualize_tree(self, root: TreeNode, filename: str = 'pascal_tree.png',
+                      show_values: bool = True, show_sierpinski: bool = False):
+        """
+        Create a visual representation of Pascal's tree.
+
+        Uses networkx and matplotlib to create a hierarchical layout
+        that clearly shows the tree structure and values.
+        """
+        G = nx.DiGraph()
+        pos = {}
+        labels = {}
+        colors = []
+
+        # Build graph using BFS
+        queue = deque([(root, 0, 0)])  # node, x_position, depth
+        x_offset = 2 ** 6  # Initial horizontal spacing
+
+        while queue:
+            node, x, depth = queue.popleft()
+            node_id = f"{node.row},{node.col}"
+
+            G.add_node(node_id)
+            pos[node_id] = (x, -depth)
+
+            if show_values:
+                labels[node_id] = str(node.value)
+            else:
+                labels[node_id] = f"({node.row},{node.col})"
+
+            # Color based on Sierpinski pattern (odd/even)
+            if show_sierpinski:
+                colors.append('red' if node.value % 2 == 1 else 'lightblue')
+            else:
+                # Color based on value magnitude
+                colors.append(node.value)
+
+            # Add edges and queue children
+            current_offset = x_offset / (2 ** (depth + 1))
+
+            if node.left:
+                left_id = f"{node.left.row},{node.left.col}"
+                G.add_edge(node_id, left_id)
+                queue.append((node.left, x - current_offset, depth + 1))
+
+            if node.right:
+                right_id = f"{node.right.row},{node.right.col}"
+                G.add_edge(node_id, right_id)
+                queue.append((node.right, x + current_offset, depth + 1))
+
+        # Create visualization
+        plt.figure(figsize=(15, 10))
+
+        if show_sierpinski:
+            nx.draw(G, pos, labels=labels, node_color=colors,
+                   node_size=500, font_size=10, font_weight='bold',
+                   with_labels=True, arrows=False)
+        else:
+            nx.draw(G, pos, labels=labels, node_color=colors,
+                   cmap='YlOrRd', node_size=500, font_size=10,
+                   font_weight='bold', with_labels=True, arrows=False)
+
+        plt.title("Pascal's Tree Visualization", fontsize=16)
+        plt.axis('off')
+        plt.tight_layout()
+        plt.savefig(filename, dpi=300, bbox_inches='tight')
+        plt.close()
+
+    def print_tree_text(self, root: TreeNode, max_depth: int = 5):
+        """
+        Print a text representation of Pascal's tree.
+
+        Uses indentation to show tree structure and includes
+        mathematical annotations.
+        """
+        print("Pascal's Tree - Text Representation")
+        print("=" * 50)
+        print("Format: value [C(row,col)] (row,col)")
+        print("=" * 50)
+
+        self._print_node_recursive(root, "", True, 0, max_depth)
+
+    def _print_node_recursive(self, node: Optional[TreeNode], prefix: str,
+                            is_tail: bool, depth: int, max_depth: int):
+        """
+        Recursively print tree nodes with proper formatting.
+        """
+        if node is None or depth > max_depth:
+            return
+
+        # Create the connection line
+        connector = "└── " if is_tail else "├── "
+
+        # Print current node
+        print(f"{prefix}{connector}{node.value} [C({node.row},{node.col})] "
+              f"({node.row},{node.col})")
+
+        # Prepare prefix for children
+        child_prefix = prefix + ("    " if is_tail else "│   ")
+
+        # Print children
+        children = []
+        if node.left:
+            children.append(node.left)
+        if node.right:
+            children.append(node.right)
+
+        for i, child in enumerate(children):
+            is_last = (i == len(children) - 1)
+            self._print_node_recursive(child, child_prefix, is_last,
+                                     depth + 1, max_depth)
+
+    def generate_fibonacci_connection_tree(self, max_depth: int) -> TreeNode:
+        """
+        Generate a tree that highlights the connection between Pascal's
+        triangle and Fibonacci numbers.
+
+        Mathematical insight: The sum of the nth diagonal in Pascal's
+        triangle equals the nth Fibonacci number.
+
+        Specifically: F(n) = Σ C(k, n-k-1) for k from 0 to floor(n/2)
+        """
+        # Build standard Pascal tree first
+        self.root = self.generate_recursive_tree(max_depth)
+
+        # Annotate nodes with Fibonacci diagonal sums
+        self._annotate_fibonacci_diagonals(self.root)
+
+        return self.root
+
+    def _annotate_fibonacci_diagonals(self, root: TreeNode):
+        """
+        Annotate tree nodes with their contribution to Fibonacci numbers.
+
+        Each diagonal starting from the edge of Pascal's triangle
+        sums to a Fibonacci number.
+        """
+        # Calculate diagonal sums
+        diagonal_sums = {}
+
+        queue = deque([root])
+        while queue:
+            node = queue.popleft()
+
+            # Diagonal index: d = row - col
+            diagonal = node.row - node.col
+
+            if diagonal not in diagonal_sums:
+                diagonal_sums[diagonal] = 0
+
+            diagonal_sums[diagonal] += node.value
+
+            # Store Fibonacci connection in node
+            node.fibonacci_diagonal = diagonal
+            node.fibonacci_contribution = node.value
+
+            if node.left:
+                queue.append(node.left)
+            if node.right:
+                queue.append(node.right)
+
+        # Verify Fibonacci property
+        print("\nFibonacci-Pascal Connection:")
+        print("Diagonal Index -> Sum = Fibonacci Number")
+        fib_a, fib_b = 1, 1
+        for d in sorted(diagonal_sums.keys()):
+            if d >= 0:
+                print(f"Diagonal {d}: Sum = {diagonal_sums[d]}, "
+                      f"Fibonacci F({d+1}) = {fib_a}")
+                fib_a, fib_b = fib_b, fib_a + fib_b
+
+    def analyze_combinatorial_interpretations(self, max_rows: int):
+        """
+        Analyze various combinatorial interpretations of Pascal's tree values.
+
+        This includes:
+        1. Binomial expansion coefficients
+        2. Number of paths in a grid
+        3. Number of subsets of a set
+        4. Catalan number connections
+        """
+        print("\nCombinatorial Interpretations of Pascal's Tree")
+        print("=" * 60)
+
+        for n in range(max_rows + 1):
+            print(f"\nRow {n}:")
+
+            # Binomial expansion: (x + y)^n
+            print(f"  Binomial expansion of (x + y)^{n}:")
+            terms = []
+            for k in range(n + 1):
+                coeff = math.comb(n, k)
+                if k == 0:
+                    terms.append(f"{coeff}x^{n}")
+                elif k == n:
+                    terms.append(f"{coeff}y^{n}")
+                else:
+                    terms.append(f"{coeff}x^{n-k}y^{k}")
+            print(f"    {' + '.join(terms)}")
+
+            # Grid paths
+            print(f"  Grid paths from (0,0) to ({n},k):")
+            for k in range(n + 1):
+                paths = math.comb(n, k)
+                print(f"    To ({n},{k}): {paths} paths "
+                      f"(choose {k} 'right' moves from {n} total moves)")
+
+            # Subset counting
+            total_subsets = 2 ** n
+            print(f"  Subsets of a set with {n} elements: {total_subsets} total")
+            for k in range(n + 1):
+                subsets_k = math.comb(n, k)
+                print(f"    Subsets of size {k}: {subsets_k}")
+
+        # Catalan numbers connection
+        print("\n\nCatalan Numbers Connection:")
+        print("Central binomial coefficients relate to Catalan numbers")
+        for n in range(min(max_rows + 1, 10)):
+            central_binom = math.comb(2*n, n)
+            catalan = central_binom // (n + 1)  # nth Catalan number
+            print(f"  C({2*n},{n}) = {central_binom}, "
+                  f"Catalan({n}) = {catalan} = C({2*n},{n})/{n+1}")
+
+
+# Example usage and demonstrations
+def demonstrate_pascal_trees():
+    """
+    Comprehensive demonstration of Pascal's tree implementations.
+    """
+    print("PASCAL'S TREE GENERATOR - COMPREHENSIVE DEMONSTRATION")
+    print("=" * 70)
+
+    # Create generator instance
+    generator = PascalTreeGenerator()
+
+    # 1. Generate recursive tree
+    print("\n1. RECURSIVE PASCAL'S TREE")
+    print("-" * 40)
+    recursive_tree = generator.generate_recursive_tree(max_depth=5)
+    generator.print_tree_text(recursive_tree, max_depth=4)
+
+    # Calculate and display properties
+    properties = generator.calculate_tree_properties(recursive_tree)
+    print("\nTree Properties:")
+    print(f"  Total nodes: {properties['total_nodes']}")
+    print(f"  Max depth: {properties['max_depth']}")
+    print(f"  Leaf nodes: {properties['leaf_nodes']}")
+    print(f"  Perfectly balanced: {properties['perfectly_balanced']}")
+
+    print("\nLevel sums (should equal 2^n):")
+    for level, verification in properties['level_sum_verification'].items():
+        status = "✓" if verification['correct'] else "✗"
+        print(f"  Level {level}: {verification['actual']} "
+              f"(expected {verification['expected']}) {status}")
+
+    # 2. Path sum tree
+    print("\n\n2. PATH SUM TREE")
+    print("-" * 40)
+    generator2 = PascalTreeGenerator()
+    path_tree = generator2.generate_path_sum_tree(max_depth=4)
+    print("Path sum tree shows how Pascal values can be computed")
+    print("by counting paths in the tree structure.")
+
+    # 3. Sierpinski tree
+    print("\n\n3. SIERPINSKI TREE (Pascal's Triangle mod 2)")
+    print("-" * 40)
+    generator3 = PascalTreeGenerator()
+    sierpinski_tree = generator3.generate_sierpinski_tree(max_depth=6)
+
+    print("Odd values in first 7 rows (forms Sierpinski triangle):")
+    for level in range(7):
+        row_values = []
+        for col in range(level + 1):
+            val = generator3._get_pascal_value(level, col)
+            row_values.append("●" if val % 2 == 1 else "○")
+        print(f"  Row {level}: {' '.join(row_values)}")
+
+    # 4. Fibonacci connection
+    print("\n\n4. FIBONACCI CONNECTION TREE")
+    print("-" * 40)
+    generator4 = PascalTreeGenerator()
+    fib_tree = generator4.generate_fibonacci_connection_tree(max_depth=7)
+
+    # 5. Combinatorial analysis
+    print("\n\n5. COMBINATORIAL INTERPRETATIONS")
+    print("-" * 40)
+    generator5 = PascalTreeGenerator()
+    generator5.analyze_combinatorial_interpretations(max_rows=4)
+
+    # 6. Mathematical relationships
+    print("\n\n6. MATHEMATICAL RELATIONSHIPS IN PASCAL'S TREE")
+    print("-" * 40)
+
+    print("\nHockey Stick Identity:")
+    print("Sum of a column: Σ C(k,r) for k=r to n equals C(n+1,r+1)")
+    n, r = 6, 2
+    column_sum = sum(math.comb(k, r) for k in range(r, n+1))
+    print(f"  Example: Σ C(k,{r}) for k={r} to {n} = {column_sum}")
+    print(f"  This equals C({n+1},{r+1}) = {math.comb(n+1, r+1)} ✓")
+
+    print("\nVandermonde's Identity:")
+    print("C(m+n,r) = Σ C(m,k) * C(n,r-k) for k=0 to r")
+    m, n, r = 3, 4, 3
+    left_side = math.comb(m+n, r)
+    right_side = sum(math.comb(m, k) * math.comb(n, r-k) for k in range(r+1))
+    print(f"  Example: C({m+n},{r}) = {left_side}")
+    print(f"  Sum of products = {right_side} ✓")
+
+    # 7. Generate visualizations
+    print("\n\n7. GENERATING VISUALIZATIONS")
+    print("-" * 40)
+
+    # Standard visualization
+    print("Creating standard Pascal's tree visualization...")
+    generator.visualize_tree(recursive_tree, 'pascal_tree_standard.png',
+                           show_values=True, show_sierpinski=False)
+
+    # Sierpinski visualization
+    print("Creating Sierpinski pattern visualization...")
+    generator3.visualize_tree(sierpinski_tree, 'pascal_tree_sierpinski.png',
+                            show_values=True, show_sierpinski=True)
+
+    print("\nVisualizations saved as:")
+    print("  - pascal_tree_standard.png")
+    print("  - pascal_tree_sierpinski.png")
+
+    return generator
+
+
+if __name__ == "__main__":
+    # Run comprehensive demonstration
+    generator = demonstrate_pascal_trees()
+
+    print("\n" + "=" * 70)
+    print("DEMONSTRATION COMPLETE")
+    print("\nPascal's tree reveals deep mathematical connections between:")
+    print("- Combinatorics (counting and choosing)")
+    print("- Number theory (divisibility patterns)")
+    print("- Fractals (Sierpinski triangle)")
+    print("- Fibonacci sequences")
+    print("- Probability theory")
+    print("- Algebraic expansions")
+    print("\nThe tree structure provides insights into the recursive")
+    print("and self-similar nature of Pascal's triangle.")

streaming.py

@@ -1,40 +1,90 @@
-# streaming.py - Fixed version to send incremental delta chunks
+# streaming.py - FINAL CORRECTED version with robust, state-aware processing.
 import json
 import re
-import logging 
+import logging
 from typing import AsyncGenerator, Callable, Optional, Iterator, Tuple
 from dataclasses import dataclass
-import sys
+import sys, re, html
 import time
 from selenium.common.exceptions import NoSuchElementException, StaleElementReferenceException, TimeoutException
 from selenium.webdriver.common.by import By
 from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
-
+from bs4 import BeautifulSoup, Tag
 
 logging.basicConfig(level=logging.INFO, stream=sys.stdout, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# --- Helper Classes (largely unchanged, but included for completeness) ---
+
+class HtmlToMarkdownConverter:
+    """
+    Converts a BeautifulSoup Tag element into a Markdown string.
+    This is designed to be called on finalized, complete HTML elements.
+    """
+    def convert_element(self, el: Tag) -> str:
+        if not isinstance(el, Tag):
+            return ""
+
+        name = el.name
+        if name == 'pre':
+            lang_match = re.search(r'class="language-(.*?)"', str(el), re.IGNORECASE)
+            lang = lang_match.group(1).strip() if lang_match else ''
+            # .get_text() from BS4 correctly preserves newlines from the code structure
+            content = el.get_text().strip()
+            return f'```{lang}\n{content}\n```'
+        if name == 'p':
+            # Convert child tags like <strong> or <code> within the paragraph
+            content = ''.join(self.convert_inline(child) for child in el.contents)
+            return content
+        if name in ['ul', 'ol']:
+            # The site's HTML for lists already contains the bullet/number in the text.
+            items = [li.get_text().strip() for li in el.find_all('li', recursive=False)]
+            return '\n'.join(items)
+        if name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
+            level = int(name[1])
+            return '#' * level + ' ' + el.get_text().strip()
+        
+        return el.get_text()
+
+    def convert_inline(self, el):
+        """Recursively converts inline elements to markdown."""
+        if isinstance(el, str):
+            return html.unescape(el)
+        if not isinstance(el, Tag):
+            return ""
+            
+        content = ''.join(self.convert_inline(child) for child in el.contents)
+        
+        if el.name == 'strong' or el.name == 'b':
+            return f'**{content}**'
+        if el.name == 'em' or el.name == 'i':
+            return f'*{content}*'
+        if el.name == 'code':
+            return f'`{content}`'
+        if el.name == 'a':
+            href = el.get('href', '')
+            return f'[{content}]({href})'
+            
+        return content
+
 
 @dataclass
 class StreamConfig:
     """Configuration for streaming behavior"""
-    timeout: float = 300.0  # Overall timeout for the stream generation
+    timeout: float = 300.0
     retry_on_error: bool = True
     max_retries: int = 3
-    # Configs below are more for the StreamProcessor
-    poll_interval: float = 0.05 
-    response_timeout: float = 900 # Max time for Selenium to wait for response content
-    stabilization_timeout: float = 1.0 # Extra wait after Selenium stream ends
-    max_inactivity: float = 10.0 # Max time between chunks from Selenium stream
+    poll_interval: float = 0.05
+    response_timeout: float = 900
+    stabilization_timeout: float = 1.0
+    max_inactivity: float = 10.0
+    stream_raw_html: bool = False
+    convert_html_to_markdown: bool = True
 
 class StreamingResponseGenerator:
-    """
-    Generates Server-Sent Events (SSE) for streaming chat completions.
-    It takes an async generator producing text deltas and formats them into SSE chunks.
-    """
-    
+    """Generates Server-Sent Events (SSE) for streaming chat completions."""
     def __init__(self, config: Optional[StreamConfig] = None):
         self.config = config or StreamConfig()
 
@@ -43,220 +93,163 @@ class StreamingResponseGenerator:
         completion_id: str,
         created: int,
         model: str,
-        prompt: str, # This is the full_prompt for the send_message_func
-        send_message_func: Callable[[str, str], AsyncGenerator[str, None]] # Called with (prompt, model)
+        prompt: str,
+        send_message_func: Callable[..., AsyncGenerator[str, None]]
     ) -> AsyncGenerator[str, None]:
-        """
-        Creates an SSE stream from the text deltas generated by send_message_func.
-        """
-        
         logger.info(f"[{completion_id}] Starting streaming response generation for model '{model}'.")
-        
         first_chunk_sent = False
         accumulated_content_for_logging = ""
-
         try:
-            # `send_message_func` is `ChatHandler.send_message_and_stream_response`
-            # It takes (prompt, model_id) and yields text deltas.
             async for content_delta in send_message_func(prompt, model):
-                if not content_delta: # Skip empty chunks from the source
-                    continue
-
+                if not content_delta: continue
                 accumulated_content_for_logging += content_delta
-                # logger.debug(f"[{completion_id}] Received content delta: '{content_delta[:50].replace(chr(10), ' ')}...' (Total: {len(accumulated_content_for_logging)})")
-
                 delta_payload = {"content": content_delta}
                 if not first_chunk_sent:
-                    # The first contentful chunk should also carry the role.
                     delta_payload["role"] = "assistant"
                     first_chunk_sent = True
-                
                 chunk_data = {
-                    "id": completion_id,
-                    "object": "chat.completion.chunk",
-                    "created": created,
-                    "model": model,
-                    "choices": [{
-                        "index": 0, 
-                        "delta": delta_payload,
-                        "finish_reason": None 
-                    }]
+                    "id": completion_id, "object": "chat.completion.chunk", "created": created, "model": model,
+                    "choices": [{"index": 0, "delta": delta_payload, "finish_reason": None}]
                 }
-                
-                chunk_json = json.dumps(chunk_data)
-                # logger.debug(f"[{completion_id}] Yielding delta chunk: data: {chunk_json}")
-                yield f"data: {chunk_json}\n\n"
+                yield f"data: {json.dumps(chunk_data)}\n\n"
             
-            # After the loop, if no content was ever sent but the stream finished,
-            # ensure at least one chunk (possibly empty with role) is sent before finish_reason.
-            # However, OpenAI spec usually sends finish_reason in a new chunk.
-            if not first_chunk_sent: # If stream ended without any content
-                logger.warning(f"[{completion_id}] Stream ended without any content. Sending empty assistant chunk before finish.")
-                empty_assistant_chunk = {
+            if not first_chunk_sent:
+                logger.warning(f"[{completion_id}] Stream ended without content. Sending empty assistant chunk.")
+                empty_chunk = {
                     "id": completion_id, "object": "chat.completion.chunk", "created": created, "model": model,
                     "choices": [{"index": 0, "delta": {"role": "assistant", "content": ""}, "finish_reason": None}]
                 }
-                yield f"data: {json.dumps(empty_assistant_chunk)}\n\n"
-
+                yield f"data: {json.dumps(empty_chunk)}\n\n"
 
-            # Send the final chunk with finish_reason
             final_chunk_data = {
-                "id": completion_id,
-                "object": "chat.completion.chunk",
-                "created": created,
-                "model": model,
-                "choices": [{
-                    "index": 0, 
-                    "delta": {}, # Empty delta
-                    "finish_reason": "stop"
-                }]
+                "id": completion_id, "object": "chat.completion.chunk", "created": created, "model": model,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]
             }
-            final_chunk_json = json.dumps(final_chunk_data)
             logger.info(f"[{completion_id}] Yielding final chunk. Total content length: {len(accumulated_content_for_logging)} chars.")
-            yield f"data: {final_chunk_json}\n\n"
-            
+            yield f"data: {json.dumps(final_chunk_data)}\n\n"
             logger.info(f"[{completion_id}] Yielding [DONE] signal.")
             yield "data: [DONE]\n\n"
-            
         except Exception as e:
             logger.error(f"[{completion_id}] Error during streaming response generation: {e}", exc_info=True)
             error_payload = {"content": f"\n\nError in stream: {str(e)}"}
-            if not first_chunk_sent: 
-                error_payload["role"] = "assistant"
-
-            error_chunk_data = {
+            if not first_chunk_sent: error_payload["role"] = "assistant"
+            error_chunk = {
                 "id": completion_id, "object": "chat.completion.chunk", "created": created, "model": model,
                 "choices": [{"index": 0, "delta": error_payload, "finish_reason": "error" }]
             }
-            yield f"data: {json.dumps(error_chunk_data)}\n\n"
-            yield "data: [DONE]\n\n" # Always end with [DONE]
+            yield f"data: {json.dumps(error_chunk)}\n\n"
+            yield "data: [DONE]\n\n"
+
+# --- Main Processor with Corrected Logic ---
 
 class StreamProcessor:
-    """Processes streaming content with stabilization detection from Selenium elements."""
-    
+    """Processes streaming content from Selenium, with stabilization and content conversion."""
     def __init__(self, config: Optional[StreamConfig] = None):
-        # Use a passed config or default StreamConfig values for processor-specific settings
-        default_cfg = StreamConfig()
-        self.poll_interval = config.poll_interval if config else default_cfg.poll_interval
-        self.response_timeout = config.response_timeout if config else default_cfg.response_timeout # For poll_element_text_stream's max_wait
-        self.stabilization_timeout = config.stabilization_timeout if config else default_cfg.stabilization_timeout
-        self.max_inactivity = config.max_inactivity if config else default_cfg.max_inactivity
-        self.request_id_for_log = "StreamProc" # Default, should be updated if possible
+        cfg = config or StreamConfig()
+        self.poll_interval = cfg.poll_interval
+        self.response_timeout = cfg.response_timeout
+        self.stabilization_timeout = cfg.stabilization_timeout
+        self.max_inactivity = cfg.max_inactivity
+        self.request_id_for_log = "StreamProc"
+        self.markdown_converter = HtmlToMarkdownConverter()
 
     def set_request_id(self, request_id: str):
         self.request_id_for_log = request_id
 
-    def read_stream_with_stabilization(self, stream_iterator: Iterator[str]) -> Iterator[str]:
+    def get_processed_text_stream(self, driver, element_locator: Tuple[str, str]) -> Iterator[str]:
+        html_stream = self._poll_element_content_stream(driver, element_locator)
+        return self._convert_html_stream_to_markdown_deltas(html_stream)
+
+    def _convert_html_stream_to_markdown_deltas(self, html_iterator: Iterator[str]) -> Iterator[str]:
         """
-        Wraps an iterator of text deltas, forwarding them while monitoring for inactivity.
-        Terminates if max_inactivity is breached or after the underlying stream is exhausted
-        and an additional stabilization_timeout has passed.
+        Statefully converts a stream of HTML snapshots to Markdown deltas.
+        It identifies "finalized" vs "active" blocks to avoid streaming
+        volatile, incomplete code blocks, preventing corruption.
         """
-        last_successful_yield_time = time.time()
-        log_prefix = f"[{self.request_id_for_log}/ReadStream]"
+        last_yielded_markdown = ""
+        last_html_snapshot = ""
 
-        try:
-            for chunk_delta in stream_iterator: # `stream_iterator` is `poll_element_text_stream`
-                current_time = time.time()
-                if current_time - last_successful_yield_time > self.max_inactivity:
-                    logger.warning(f"{log_prefix} Max inactivity ({self.max_inactivity:.2f}s) breached. Ending stream.")
-                    return 
+        for full_html_snapshot in html_iterator:
+            last_html_snapshot = full_html_snapshot
+            soup = BeautifulSoup(f"<ol>{full_html_snapshot}</ol>", 'lxml')
+            
+            # Find all content blocks in the last message bubble.
+            # The structure is <ol> -> <div> (bubble) -> ... -> <div class="prose"> -> <p/pre/ul>
+            all_prose_divs = soup.select('div.prose')
+            if not all_prose_divs:
+                continue
 
-                if chunk_delta:
-                    yield chunk_delta
-                    last_successful_yield_time = current_time
-                # No specific handling for empty chunk here as poll_element_text_stream filters them.
+            content_elements = [div.contents[0] for div in all_prose_divs if div.contents]
             
-            # Underlying stream_iterator is now exhated.
-            # Wait for an additional stabilization_timeout period.
-            time_since_last_yield = time.time() - last_successful_yield_time
-            if time_since_last_yield < self.stabilization_timeout:
-                wait_needed = self.stabilization_timeout - time_since_last_yield
-                if wait_needed > 0.01: # Only log/sleep if meaningful wait
-                    logger.debug(f"{log_prefix} Underlying stream exhausted. Waiting for stabilization: {wait_needed:.2f}s.")
-                    time.sleep(wait_needed)
-            logger.debug(f"{log_prefix} Stabilization complete or underlying stream ended.")
+            finalized_elements = content_elements
+            # Check if the very last element is an incomplete code block.
+            # If so, we don't process it in this pass, we wait for it to be finalized.
+            if content_elements and content_elements[-1].name == 'pre':
+                finalized_elements = content_elements[:-1]
+
+            # Convert all finalized elements to markdown
+            md_pieces = [self.markdown_converter.convert_element(el) for el in finalized_elements]
+            current_safe_markdown = "\n\n".join(md_pieces)
+
+            # Yield the delta if it's a simple append
+            if current_safe_markdown != last_yielded_markdown:
+                 if current_safe_markdown.startswith(last_yielded_markdown):
+                    delta = current_safe_markdown[len(last_yielded_markdown):]
+                    if delta:
+                        yield delta.lstrip('\n')
+                 last_yielded_markdown = current_safe_markdown
+        
+        # After the loop, the stream has finished. Process the very last snapshot in full.
+        final_soup = BeautifulSoup(f"<ol>{last_html_snapshot}</ol>", 'lxml')
+        all_prose_divs = final_soup.select('div.prose')
+        content_elements = [div.contents[0] for div in all_prose_divs if div.contents]
+        final_md_pieces = [self.markdown_converter.convert_element(el) for el in content_elements]
+        final_markdown = "\n\n".join(final_md_pieces)
 
-        except Exception as e:
-            logger.error(f"{log_prefix} Error: {e}", exc_info=True)
-            return
+        if final_markdown.startswith(last_yielded_markdown):
+            final_delta = final_markdown[len(last_yielded_markdown):]
+            if final_delta:
+                yield final_delta.lstrip('\n')
 
-    def poll_element_text_stream(self, driver, element_locator: Tuple[str, str]) -> Iterator[str]:
-        """
-        Polls a web element's text content and yields incremental changes (deltas).
-        Stops if the element disappears, or if `self.response_timeout` is reached and text has not changed.
-        """
+
+    def _poll_element_content_stream(self, driver, element_locator: Tuple[str, str]) -> Iterator[str]:
         log_prefix = f"[{self.request_id_for_log}/PollStream]"
-        start_time_for_stream = time.time()
-        last_text = ""
-        element_previously_found = False
+        start_time = time.time()
+        last_content = ""
         last_change_time = time.time()
 
-        logger.debug(f"{log_prefix} Starting to poll {element_locator} for text. Max wait: {self.response_timeout}s, Poll interval: {self.poll_interval}s.")
-
-        while time.time() - start_time_for_stream < self.response_timeout:
+        while time.time() - start_time < self.response_timeout:
             loop_start_time = time.time()
             try:
-                # Re-evaluate WebDriverWait for presence here
-                element = WebDriverWait(driver, self.poll_interval * 2, poll_frequency=self.poll_interval/2).until(
-                    EC.presence_of_element_located(element_locator)
-                )
-                element_previously_found = True
-                
-                current_text = element.text
-                
-                if current_text != last_text:
-                    new_text_delta = current_text[len(last_text):]
-                    if new_text_delta:
-                        # logger.debug(f"{log_prefix} Yielding delta (len {len(new_text_delta)}): '{new_text_delta[:30].replace(chr(10),' ')}...'")
-                        yield new_text_delta
-                        last_change_time = time.time() # Update time of last actual text change
-                    last_text = current_text
-                else:
-                    # Text has not changed. If no change for `max_inactivity` (handled by read_stream_with_stabilization)
-                    # or if `response_timeout` (overall) is hit, it will stop.
-                    # This specific condition checks if text has stabilized for a duration longer than max_inactivity
-                    # If this poller's `response_timeout` is very long, it relies on the outer wrapper's max_inactivity.
-                    if time.time() - last_change_time > self.max_inactivity : # Check inactivity from *this* poller's perspective
-                        logger.info(f"{log_prefix} Text has not changed for {self.max_inactivity:.2f}s. Assuming stable.")
-                        return
-
-            except TimeoutException: # From WebDriverWait if element not present within its short timeout
-                if element_previously_found:
-                    logger.info(f"{log_prefix} Element {element_locator} became non-present after being found. Assuming stream ended.")
+                element = WebDriverWait(driver, self.poll_interval * 2).until(EC.presence_of_element_located(element_locator))
+                current_content = element.get_attribute('innerHTML')
+                if current_content != last_content:
+                    yield current_content
+                    last_content = current_content
+                    last_change_time = time.time()
+                elif time.time() - last_change_time > self.max_inactivity:
+                    logger.info(f"{log_prefix} Content stable for {self.max_inactivity:.2f}s. Ending poll.")
                     return
-                # else: Element not yet appeared, continue polling up to self.response_timeout
-                logger.debug(f"{log_prefix} Element {element_locator} not present yet. Continuing poll.")
-            except StaleElementReferenceException:
-                logger.warning(f"{log_prefix} StaleElementReferenceException for {element_locator}. Resetting and retrying find.")
-                last_text = "" 
-                element_previously_found = False 
-            except NoSuchElementException: # Should be caught by WebDriverWait's TimeoutException mostly
-                logger.warning(f"{log_prefix} NoSuchElementException for {element_locator} (should be rare with WebDriverWait).")
-                if element_previously_found: return 
+            except (TimeoutException, StaleElementReferenceException, NoSuchElementException):
+                logger.debug(f"{log_prefix} Element not present or stale. Continuing poll.")
             except Exception as e:
-                logger.error(f"{log_prefix} Unexpected error polling {element_locator}: {e}", exc_info=True)
+                logger.error(f"{log_prefix} Unexpected error polling: {e}", exc_info=True)
                 return
+            
+            sleep_duration = self.poll_interval - (time.time() - loop_start_time)
+            if sleep_duration > 0: time.sleep(sleep_duration)
+        logger.warning(f"{log_prefix} Polling finished due to max wait ({self.response_timeout:.2f}s).")
 
-            elapsed_in_loop = time.time() - loop_start_time
-            sleep_duration = self.poll_interval - elapsed_in_loop
-            if sleep_duration > 0:
-                time.sleep(sleep_duration)
-        
-        logger.info(f"{log_prefix} Max_wait ({self.response_timeout:.2f}s) reached for polling {element_locator} or stream naturally ended.")
-
-
-# Wrapper for creating the generator instance easily
 async def create_streaming_response(
     completion_id: str,
     created: int,
     model: str,
     prompt: str,
-    send_message_func: Callable[[str, str], AsyncGenerator[str, None]],
-    stream_config: Optional[StreamConfig] = None # Allow passing specific config
+    send_message_func: Callable[..., AsyncGenerator[str, None]],
+    stream_config: Optional[StreamConfig] = None
 ) -> AsyncGenerator[str, None]:
     generator = StreamingResponseGenerator(config=stream_config)
     async for chunk in generator.create_response(completion_id, created, model, prompt, send_message_func):
         yield chunk
 
-__all__ = ['create_streaming_response', 'StreamingResponseGenerator', 'StreamConfig', 'StreamProcessor']
+__all__ = ['create_streaming_response', 'StreamingResponseGenerator', 'StreamConfig', 'StreamProcessor', 'HtmlToMarkdownConverter']

test_api.py

@@ -8,31 +8,10 @@ import random
 # Configure the OpenAI client to point to the local server.
 # The API key is required by the library but not used by the local server.
 client = OpenAI(
-    base_url="https://solarumasteridion-lenith.hf.space/",
+    base_url="http://localhost:8000/",
     api_key=os.environ.get("OPENAI_API_KEY", "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") 
 )
 
-@pytest.mark.asyncio
-async def test_list_models_openai():
-    """Test the /models endpoint to get a list of available models."""
-    print("\nTesting /models endpoint...")
-    try:
-        start_time = time.time()
-        models_response = client.models.list()
-        end_time = time.time()
-        
-        print(f"Received response from /models in {end_time - start_time:.2f}s")
-        assert models_response is not None
-        assert len(models_response.data) > 0, "No models were returned from the /models endpoint."
-        
-        print(f"Found {len(models_response.data)} models:")
-        for model in models_response.data:
-            print(f" - Model ID: {model.id}")
-            assert isinstance(model.id, str)
-            assert model.object == "model"
-        
-    except Exception as e:
-        pytest.fail(f"/models endpoint test failed using openai lib: {e}")
 
 @pytest.mark.asyncio
 async def test_chat_completion_streaming_openai():
@@ -40,29 +19,16 @@ async def test_chat_completion_streaming_openai():
     Test the /chat/completions endpoint for streaming requests.
     This test first fetches an available model from the /models endpoint.
     """
+    messages = [{"role": "user", "content": "bionomial thoerem calc in python concise code but explain before the code block"}]
     
-    # Step 1: Get the list of available models first to make the test robust.
-    print("\nFetching available models before chat completion test...")
-    try:
-        models_response = client.models.list()
-        assert len(models_response.data) > 0, "Cannot run chat completion test: no models available."
-        # Use the first model from the list for the test.
-        model_to_test = models_response.data[random.randint(0, len(models_response.data) - 1)].id
-        print(f"Will use model '{model_to_test}' for the test.")
-    except Exception as e:
-        pytest.fail(f"Failed to fetch models before running chat completion test: {e}")
-
-    # Step 2: Use the fetched model to run the chat completion test.
-    messages = [{"role": "user", "content": "squirrel pet simulator in python with emojis"}]
-    
-    print(f"\nTesting streaming chat completion with model '{model_to_test}'...")
+    print(f"\nTesting streaming chat completion with model 'Gemini 2.0 Flash'...")
     accumulated_content = ""
     deltas_received = 0
     start_time = time.time()
     
     try:
         stream = client.chat.completions.create(
-            model=model_to_test,
+            model="Gemini 2.0 Flash",
             messages=messages,
             stream=True
         )  
@@ -100,7 +66,6 @@ async def test_chat_completion_streaming_openai():
         
         assert deltas_received > 0, "No content deltas were received."
         assert len(accumulated_content) > 0, "Accumulated content is empty."
-        assert "squirrel" in accumulated_content.lower(), "Story does not seem to be about a squirrel."
-
+       
     except Exception as e:
         pytest.fail(f"Streaming chat completion failed: {e}")