symbolicai 0.20.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

symai/backend/engines/search/engine_openai.py

@@ -9,7 +9,7 @@ from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 from openai import OpenAI
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...mixin import OPENAI_CHAT_MODELS, OPENAI_REASONING_MODELS
 from ...settings import SYMAI_CONFIG
@@ -40,7 +40,7 @@ class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
         if value.get('error'):
-            CustomUserWarning(value['error'], raise_with=ValueError)
+            UserMessage(value['error'], raise_with=ValueError)
         try:
             text, annotations = self._extract_text_and_annotations(value)
             if text is None:
@@ -56,7 +56,7 @@ class SearchResult(Result):
 
         except Exception as e:
             self._value = None
-            CustomUserWarning(f"Failed to parse response: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to parse response: {e}", raise_with=ValueError)
 
     def _extract_text(self, value) -> str | None:
         if isinstance(value.get('output_text'), str) and value.get('output_text'):
@@ -65,7 +65,7 @@ class SearchResult(Result):
         for output in value.get('output', []):
             if output.get('type') == 'message' and output.get('content'):
                 content0 = output['content'][0]
-                if 'text' in content0 and content0['text']:
+                if content0.get('text'):
                     text = content0['text']
         return text
 
@@ -223,7 +223,7 @@ class SearchResult(Result):
         try:
             return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
         except Exception:
-            return f"<pre>{str(self.raw)}</pre>"
+            return f"<pre>{self.raw!s}</pre>"
 
     def get_citations(self) -> list[Citation]:
         return self._citations
@@ -244,7 +244,7 @@ class GPTXSearchEngine(Engine):
         try:
             self.client = OpenAI(api_key=self.api_key)
         except Exception as e:
-            CustomUserWarning(f"Failed to initialize OpenAI client: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to initialize OpenAI client: {e}", raise_with=ValueError)
 
     def id(self) -> str:
         if self.config.get('SEARCH_ENGINE_API_KEY') and \
@@ -350,7 +350,7 @@ class GPTXSearchEngine(Engine):
             res = self.client.responses.create(**payload)
             res = SearchResult(res.dict())
         except Exception as e:
-            CustomUserWarning(f"Failed to make request: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to make request: {e}", raise_with=ValueError)
 
         metadata = {"raw_output": res.raw}
         output   = [res]

symai/backend/engines/search/engine_perplexity.py

@@ -4,7 +4,7 @@ import logging
 import requests
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
@@ -18,12 +18,12 @@ class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
         if value.get('error'):
-            CustomUserWarning(value['error'], raise_with=ValueError)
+            UserMessage(value['error'], raise_with=ValueError)
         try:
             self._value = value['choices'][0]['message']['content']
         except Exception as e:
             self._value = None
-            CustomUserWarning(f"Failed to parse response: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to parse response: {e}", raise_with=ValueError)
 
     def __str__(self) -> str:
         try:
@@ -35,7 +35,7 @@ class SearchResult(Result):
         try:
             return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
         except TypeError:
-            return f"<pre>{str(self.raw)}</pre>"
+            return f"<pre>{self.raw!s}</pre>"
 
 
 class PerplexityEngine(Engine):
@@ -91,7 +91,7 @@ class PerplexityEngine(Engine):
             res = requests.post("https://api.perplexity.ai/chat/completions", json=payload, headers=headers)
             res = SearchResult(res.json())
         except Exception as e:
-            CustomUserWarning(f"Failed to make request: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to make request: {e}", raise_with=ValueError)
 
         metadata = {"raw_output": res.raw}
         output   = [res]

symai/backend/engines/search/engine_serpapi.py

@@ -3,31 +3,31 @@ import json
 from IPython.utils import io
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 try:
     from serpapi import GoogleSearch
-except:
+except ImportError:
     GoogleSearch = None
 
 
 class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
-        if 'answer_box' in value.keys() and 'answer' in value['answer_box'].keys():
+        if 'answer_box' in value and 'answer' in value['answer_box']:
             self._value = value['answer_box']['answer']
-        elif 'answer_box' in value.keys() and 'snippet' in value['answer_box'].keys():
+        elif 'answer_box' in value and 'snippet' in value['answer_box']:
             self._value = value['answer_box']['snippet']
-        elif 'answer_box' in value.keys() and 'snippet_highlighted_words' in value['answer_box'].keys():
+        elif 'answer_box' in value and 'snippet_highlighted_words' in value['answer_box']:
             self._value = value['answer_box']["snippet_highlighted_words"][0]
-        elif 'organic_results' in value and 'snippet' in value["organic_results"][0].keys():
+        elif 'organic_results' in value and 'snippet' in value["organic_results"][0]:
             self._value = value["organic_results"][0]['snippet']
         else:
             self._value = value
 
-        if 'organic_results' in value.keys():
+        if 'organic_results' in value:
             self.results = value['organic_results']
             if len(self.results) > 0:
                 self.links = [r['link'] for r in self.results]
@@ -38,12 +38,10 @@ class SearchResult(Result):
             self.links = []
 
     def __str__(self) -> str:
-        json_str = json.dumps(self.raw, indent=2)
-        return json_str
+        return json.dumps(self.raw, indent=2)
 
     def _repr_html_(self) -> str:
-        json_str = json.dumps(self.raw, indent=2)
-        return json_str
+        return json.dumps(self.raw, indent=2)
 
 
 class SerpApiEngine(Engine):
@@ -57,7 +55,7 @@ class SerpApiEngine(Engine):
     def id(self) -> str:
         if self.config.get('SEARCH_ENGINE_API_KEY') and self.config.get('SEARCH_ENGINE_MODEL') == "google": # only support Google for now
             if GoogleSearch is None:
-                CustomUserWarning('SerpApi is not installed. Please install it with `pip install symbolicai[serpapi]`')
+                UserMessage('SerpApi is not installed. Please install it with `pip install symbolicai[serpapi]`')
             return 'search'
         return super().id() # default to unregistered
 
@@ -73,7 +71,7 @@ class SerpApiEngine(Engine):
         kwargs   = argument.kwargs
         queries_ = queries if isinstance(queries, list) else [queries]
         rsp      = []
-        engine   = kwargs['engine'] if 'engine' in kwargs else self.engine
+        engine   = kwargs.get('engine', self.engine)
 
         for q in queries_:
             query = {
@@ -86,7 +84,7 @@ class SerpApiEngine(Engine):
             }
 
             # send to Google
-            with io.capture_output() as captured: # disables prints from GoogleSearch
+            with io.capture_output(): # disables prints from GoogleSearch
                 search = GoogleSearch(query)
                 res = search.get_dict()
 

symai/backend/engines/speech_to_text/engine_local_whisper.py

@@ -1,19 +1,18 @@
-import logging
+import contextlib
 import re
+from collections.abc import Iterable
 from itertools import takewhile
-from typing import Iterable
 
 import torch
 
 from ....symbol import Expression, Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 try:
     import whisper
-    from whisper.audio import \
-        N_SAMPLES  # @NOTE: sample_rate (16_000) * chunk_length (30) = 480_000
+    from whisper.audio import N_SAMPLES  # @NOTE: sample_rate (16_000) * chunk_length (30) = 480_000
     from whisper.tokenizer import get_tokenizer
 except ImportError:
     whisper   = None
@@ -27,10 +26,10 @@ class WhisperTimestampsFormatter(Expression):
     def forward(self, response: list[str]) -> str:
         result = []
         for i, interval in enumerate(response):
-            interval = self._filter_empty_string(interval)
+            interval_tokens = self._filter_empty_string(interval)
             prev_end = 0.0
             prev_start = 0.0
-            for head, tail in zip(interval[::2], interval[1::2]):
+            for head, tail in zip(interval_tokens[::2], interval_tokens[1::2], strict=False):
                 start = self._get_timestamp(head)
                 end = self._get_timestamp(tail)
                 if start >= prev_end:
@@ -46,10 +45,7 @@ class WhisperTimestampsFormatter(Expression):
                     start = prev_end
                 else:
                     start += prev_end
-                if start + delta > 30:
-                    end = 30
-                else:
-                    end = start + delta
+                end = 30 if start + delta > 30 else start + delta
                 prev_end = end
                 result.append(f"{self._format_to_hours(start + (i*30))} {self._get_sentence(head)}")
         return "\n".join(result)
@@ -68,8 +64,7 @@ class WhisperTimestampsFormatter(Expression):
         seconds %= 3600
         minutes = int(seconds // 60)
         seconds %= 60
-        formatted_time = "{:02d}:{:02d}:{:02d}".format(hours, minutes, int(seconds))
-        return formatted_time
+        return f"{hours:02d}:{minutes:02d}:{int(seconds):02d}"
 
 
 class WhisperResult(Result):
@@ -80,16 +75,16 @@ class WhisperResult(Result):
 
     def get_bins(self, bin_size_s: int = 5 * 60) -> list[str]:
         tmps = list(map(self._seconds, re.findall(r"\b\d{2}:\d{2}:\d{2}\b", self._value)))
-        value_pairs = list(zip(tmps, self._value.split("\n")))
-        bin = []
+        value_pairs = list(zip(tmps, self._value.split("\n"), strict=False))
+        bin_segments = []
         result = []
         for tmp, seg in value_pairs:
-            bin.append(seg)
+            bin_segments.append(seg)
             if tmp == 0 or (tmp - bin_size_s) % bin_size_s != 0:
                 continue
-            result.append("\n".join(bin))
-            bin = []
-        result.append("\n".join(bin))
+            result.append("\n".join(bin_segments))
+            bin_segments = []
+        result.append("\n".join(bin_segments))
         return result
 
     def _seconds(self, tmp: str) -> int:
@@ -115,7 +110,7 @@ class WhisperEngine(Engine):
             try:
                 self.model = whisper.load_model(self.model_id, device=device)
             except RuntimeError:
-                CustomUserWarning(f"Whisper failed to load model on device {device}. Fallback to {device_fallback}.")
+                UserMessage(f"Whisper failed to load model on device {device}. Fallback to {device_fallback}.")
                 self.model = whisper.load_model(self.model_id, device=device_fallback)
             self.old_model_id = self.model_id
 
@@ -124,7 +119,7 @@ class WhisperEngine(Engine):
     def id(self) -> str:
         if self.config['SPEECH_TO_TEXT_ENGINE_MODEL']:
             if whisper is None:
-                CustomUserWarning("Whisper is not installed. Please install it with `pip install symbolicai[whisper]`", raise_with=ImportError)
+                UserMessage("Whisper is not installed. Please install it with `pip install symbolicai[whisper]`", raise_with=ImportError)
             return 'speech-to-text'
         return super().id() # default to unregistered
 
@@ -153,8 +148,8 @@ class WhisperEngine(Engine):
             rsp = max(probs, key=probs.get)
         elif prompt == 'decode':
             if show_pbar:
-                # supress tqdm warning
-                from tqdm import tqdm
+                # Suppress tqdm warning; keep optional dependency lazy.
+                from tqdm import tqdm # noqa
                 pbar = tqdm(self._get_chunks(audio))
             else:
                 pbar = self._get_chunks(audio)
@@ -180,7 +175,7 @@ class WhisperEngine(Engine):
             else:
                 rsp = " ".join(self.text)
         else:
-            CustomUserWarning(f"Unknown whisper command prompt: {prompt}", raise_with=ValueError)
+            UserMessage(f"Unknown whisper command prompt: {prompt}", raise_with=ValueError)
 
         metadata = {}
         rsp = WhisperResult(rsp)
@@ -204,7 +199,5 @@ class WhisperEngine(Engine):
             yield torch.tensor(it[i:min(i + batch, size)]).to(self.model.device)
 
     def _try_compile(self):
-        try:
+        with contextlib.suppress(Exception):
             self.model = torch.compile(self.model)
-        except Exception:
-            pass

symai/backend/engines/symbolic/engine_wolframalpha.py

@@ -1,14 +1,14 @@
 from copy import deepcopy
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 try:
     import wolframalpha as wa
 except ImportError:
-    CustomUserWarning("WolframAlpha is not installed. Please install it with `pip install symbolicai[wolframalpha]`", raise_with=ImportError)
+    UserMessage("WolframAlpha is not installed. Please install it with `pip install symbolicai[wolframalpha]`", raise_with=ImportError)
 
 
 class WolframResult(Result):
@@ -45,7 +45,7 @@ class WolframAlphaEngine(Engine):
             rsp = self.client.query(queries)
             rsp = WolframResult(rsp)
         except Exception as e:
-            CustomUserWarning(f'Failed to interact with WolframAlpha: {e}.\n\n If you are getting an error related to "assert", that is a well-known issue with WolframAlpha. There is a manual fix for this issue: https://github.com/jaraco/wolframalpha/pull/34/commits/6eb3828ee812f65592e00629710fc027d40e7bd1', raise_with=ValueError)
+            UserMessage(f'Failed to interact with WolframAlpha: {e}.\n\n If you are getting an error related to "assert", that is a well-known issue with WolframAlpha. There is a manual fix for this issue: https://github.com/jaraco/wolframalpha/pull/34/commits/6eb3828ee812f65592e00629710fc027d40e7bd1', raise_with=ValueError)
 
         metadata = {}
 

symai/backend/engines/text_to_speech/engine_openai.py

@@ -1,18 +1,17 @@
 import logging
 
 from openai import OpenAI
-from typing import Optional
-
-# suppress openai logging
-logging.getLogger("openai").setLevel(logging.WARNING)
 
+from ....symbol import Result
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
-from ....symbol import Result
+
+# suppress openai logging
+logging.getLogger("openai").setLevel(logging.WARNING)
 
 
 class TTSEngine(Engine):
-    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+    def __init__(self, api_key: str | None = None, model: str | None = None):
         super().__init__()
         self.config = SYMAI_CONFIG
         self.api_key = self.config['TEXT_TO_SPEECH_ENGINE_API_KEY'] if api_key is None else api_key
@@ -35,7 +34,6 @@ class TTSEngine(Engine):
             self.model_id = kwargs['TEXT_TO_SPEECH_ENGINE_MODEL']
 
     def forward(self, argument):
-        kwargs              = argument.kwargs
         voice, path, prompt = argument.prop.prepared_input
 
         rsp = self.client.audio.speech.create(

symai/backend/engines/text_vision/engine_clip.py

@@ -1,22 +1,21 @@
 import logging
-import requests
+from io import BytesIO
 
+import requests
 import torch
-from typing import Optional
 from PIL import Image
-from io import BytesIO
 from transformers import CLIPModel, CLIPProcessor
 
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
-
 # supress warnings
 logging.getLogger("PIL").setLevel(logging.WARNING)
 
 
 class CLIPEngine(Engine):
-    def __init__(self, model: Optional[str] = None):
+    def __init__(self, model: str | None = None):
         super().__init__()
         self.model =  None # lazy loading
         self.preprocessor = None # lazy loading
@@ -44,11 +43,8 @@ class CLIPEngine(Engine):
             if isinstance(img, bytes):
                 images.append(Image.open(BytesIO(img)))
             elif isinstance(img, str):
-                if img.startswith('http'):
-                    image_ = requests.get(img, stream=True).raw
-                else:
-                    image_ = img
-                image = Image.open(image_)
+                image_source = requests.get(img, stream=True).raw if img.startswith('http') else img
+                image = Image.open(image_source)
                 images.append(image)
         return images
 
@@ -75,7 +71,7 @@ class CLIPEngine(Engine):
             logits_per_image  = outputs.logits_per_image  # this is the image-text similarity score
             rsp               = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
         else:
-            raise NotImplementedError("CLIPEngine requires either image or text input.")
+            UserMessage("CLIPEngine requires either image or text input.", raise_with=NotImplementedError)
 
         rsp = rsp.squeeze().detach().cpu().numpy()
 

symai/backend/engines/userinput/engine_console.py

@@ -1,5 +1,5 @@
-from typing import List
 
+from ....utils import UserMessage
 from ...base import Engine
 
 
@@ -15,9 +15,9 @@ class UserInputEngine(Engine):
         msg = argument.prop.prepared_input
         kwargs = argument.kwargs
 
-        mock = kwargs['mock'] if 'mock' in kwargs else False
+        mock = kwargs.get('mock', False)
         if mock: # mock user input
-            print(msg, end='') # print prompt
+            UserMessage(msg)
             rsp = mock
         else:
             rsp = input(msg)

symai/backend/engines/webscraping/engine_requests.py

@@ -10,6 +10,7 @@ service disruption.
 import io
 import logging
 import re
+from typing import Any, ClassVar
 from urllib.parse import parse_qsl, urlencode, urljoin, urlparse, urlunparse
 
 import requests
@@ -19,6 +20,7 @@ from pdfminer.high_level import extract_text
 from requests.structures import CaseInsensitiveDict
 
 from ....symbol import Result
+from ....utils import UserMessage
 from ...base import Engine
 
 logging.getLogger("pdfminer").setLevel(logging.WARNING)
@@ -56,14 +58,14 @@ class RequestsEngine(Engine):
     the requests session stay aligned.
     """
 
-    COMMON_BYPASS_COOKIES = {
+    COMMON_BYPASS_COOKIES: ClassVar[dict[str, str]] = {
         # Some forums display consent or age gates once if a friendly cookie is set.
         "cookieconsent_status": "allow",
         "accepted_cookies": "yes",
         "age_verified": "1",
     }
 
-    DEFAULT_HEADERS = {
+    DEFAULT_HEADERS: ClassVar[dict[str, str]] = {
         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                       "AppleWebKit/537.36 (KHTML, like Gecko) "
                       "Chrome/120.0.0.0 Safari/537.36",
@@ -72,7 +74,7 @@ class RequestsEngine(Engine):
         "DNT": "1",
     }
 
-    _SAMESITE_CANONICAL = {
+    _SAMESITE_CANONICAL: ClassVar[dict[str, str]] = {
         "strict": "Strict",
         "lax": "Lax",
         "none": "None",
@@ -156,6 +158,56 @@ class RequestsEngine(Engine):
             payload["sameSite"] = same_site
         return payload
 
+    def _collect_playwright_cookies(self, hostname: str) -> list[dict[str, Any]]:
+        if not hostname:
+            return []
+        cookie_payload = []
+        for cookie in self.session.cookies:
+            payload = self._playwright_cookie_payload(cookie, hostname)
+            if payload:
+                cookie_payload.append(payload)
+        return cookie_payload
+
+    @staticmethod
+    def _add_cookies_to_context(context, cookie_payload: list[dict[str, Any]]) -> None:
+        if cookie_payload:
+            context.add_cookies(cookie_payload)
+
+    @staticmethod
+    def _navigate_playwright_page(page, url: str, wait_selector: str | None, wait_until: str, timeout_ms: int, timeout_error):
+        try:
+            response = page.goto(url, wait_until=wait_until, timeout=timeout_ms)
+            if wait_selector:
+                page.wait_for_selector(wait_selector, timeout=timeout_ms)
+            return response, None
+        except timeout_error as exc:
+            return None, exc
+
+    @staticmethod
+    def _safe_page_content(page) -> str:
+        try:
+            return page.content()
+        except Exception:
+            return ""
+
+    def _sync_cookies_from_context(self, context) -> None:
+        for cookie in context.cookies():
+            self.session.cookies.set(
+                cookie["name"],
+                cookie["value"],
+                domain=cookie.get("domain"),
+                path=cookie.get("path", "/"),
+            )
+
+    @staticmethod
+    def _rendered_response_metadata(page, response):
+        final_url = page.url
+        status = response.status if response is not None else 200
+        headers = CaseInsensitiveDict(response.headers if response is not None else {})
+        if "content-type" not in headers:
+            headers["Content-Type"] = "text/html; charset=utf-8"
+        return final_url, status, headers
+
     def _follow_meta_refresh(self, resp, timeout=15):
         """
         Some old forums use <meta http-equiv="refresh" content="0;url=...">
@@ -180,19 +232,21 @@ class RequestsEngine(Engine):
             return resp
         return self.session.get(target, timeout=timeout, allow_redirects=True)
 
-    def _fetch_with_playwright(self, url: str, wait_selector: str = None, wait_until: str = "networkidle", timeout: float = None):
+    def _fetch_with_playwright(self, url: str, wait_selector: str | None = None, wait_until: str = "networkidle", timeout: float | None = None):
         """
         Render the target URL in a headless browser to execute JavaScript and
         return a synthetic ``requests.Response`` object to keep downstream
         processing consistent with the non-JS path.
         """
         try:
-            from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
+            # Playwright is optional; import only when JS rendering is requested.
+            from playwright.sync_api import TimeoutError as PlaywrightTimeoutError # noqa
+            from playwright.sync_api import sync_playwright # noqa
             logging.getLogger("playwright").setLevel(logging.WARNING)
         except ImportError as exc:
-            raise RuntimeError(
-                "Playwright is not installed. Install symbolicai[webscraping] with Playwright extras to enable render_js."
-            ) from exc
+            msg = "Playwright is not installed. Install symbolicai[webscraping] with Playwright extras to enable render_js."
+            UserMessage(msg)
+            raise RuntimeError(msg) from exc
 
         timeout_seconds = timeout if timeout is not None else self.timeout
         timeout_ms = max(int(timeout_seconds * 1000), 0)
@@ -200,12 +254,7 @@ class RequestsEngine(Engine):
 
         parsed = urlparse(url)
         hostname = parsed.hostname or ""
-        cookie_payload = []
-        if hostname:
-            for cookie in self.session.cookies:
-                payload = self._playwright_cookie_payload(cookie, hostname)
-                if payload:
-                    cookie_payload.append(payload)
+        cookie_payload = self._collect_playwright_cookies(hostname)
 
         content = ""
         final_url = url
@@ -219,42 +268,26 @@ class RequestsEngine(Engine):
                 java_script_enabled=True,
                 ignore_https_errors=not self.verify_ssl,
             )
-            if cookie_payload:
-                context.add_cookies(cookie_payload)
-            page = context.new_page()
-
-            navigation_error = None
-            response = None
             try:
-                try:
-                    response = page.goto(url, wait_until=wait_until, timeout=timeout_ms)
-                    if wait_selector:
-                        page.wait_for_selector(wait_selector, timeout=timeout_ms)
-                except PlaywrightTimeoutError as exc:
-                    navigation_error = exc
-
-                try:
-                    content = page.content()
-                except Exception:
-                    content = ""
-
-                # Always persist Playwright cookies back into the requests session.
-                for cookie in context.cookies():
-                    self.session.cookies.set(
-                        cookie["name"],
-                        cookie["value"],
-                        domain=cookie.get("domain"),
-                        path=cookie.get("path", "/"),
-                    )
-
-                final_url = page.url
-                status = response.status if response is not None else 200
-                headers = CaseInsensitiveDict(response.headers if response is not None else {})
-                if "content-type" not in headers:
-                    headers["Content-Type"] = "text/html; charset=utf-8"
-
+                self._add_cookies_to_context(context, cookie_payload)
+                page = context.new_page()
+
+                response, navigation_error = self._navigate_playwright_page(
+                    page,
+                    url,
+                    wait_selector,
+                    wait_until,
+                    timeout_ms,
+                    PlaywrightTimeoutError,
+                )
+                content = self._safe_page_content(page)
+                self._sync_cookies_from_context(context)
+
+                final_url, status, headers = self._rendered_response_metadata(page, response)
                 if navigation_error and not content:
-                    raise requests.exceptions.Timeout(f"Playwright timed out while rendering {url}") from navigation_error
+                    msg = f"Playwright timed out while rendering {url}"
+                    UserMessage(msg)
+                    raise requests.exceptions.Timeout(msg) from navigation_error
             finally:
                 context.close()
                 browser.close()

symai/backend/mixin/__init__.py

@@ -8,3 +8,16 @@ from .groq import SUPPORTED_CHAT_MODELS as GROQ_CHAT_MODELS
 from .groq import SUPPORTED_REASONING_MODELS as GROQ_REASONING_MODELS
 from .openai import SUPPORTED_CHAT_MODELS as OPENAI_CHAT_MODELS
 from .openai import SUPPORTED_REASONING_MODELS as OPENAI_REASONING_MODELS
+
+__all__ = [
+    "ANTHROPIC_CHAT_MODELS",
+    "ANTHROPIC_REASONING_MODELS",
+    "DEEPSEEK_CHAT_MODELS",
+    "DEEPSEEK_REASONING_MODELS",
+    "GOOGLE_CHAT_MODELS",
+    "GOOGLE_REASONING_MODELS",
+    "GROQ_CHAT_MODELS",
+    "GROQ_REASONING_MODELS",
+    "OPENAI_CHAT_MODELS",
+    "OPENAI_REASONING_MODELS",
+]