webscout 8.3.2__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/AIutel.py

@@ -1,5 +1,6 @@
 import codecs
 import json
+import re
 from typing import (
     Any,
     AsyncGenerator,
@@ -48,17 +49,6 @@ def _process_chunk(
         error_handler (Optional[Callable[[Exception, str], Optional[Any]]]): An optional callback function that is called when JSON parsing fails.
             It receives the exception and the sanitized chunk as arguments.  It should return a value to yield instead of the raw chunk, or None to ignore.
 
-
-    Args:
-        chunk: Chunk of text to process.
-        intro_value: Prefix to remove from the chunk.
-        to_json: Parse the chunk as JSON if True.
-        skip_markers: List of markers to skip.
-        strip_chars: Characters to strip from the chunk.
-        yield_raw_on_error: Whether to return the raw chunk on parse errors.
-        error_handler: Optional callback ``Callable[[Exception, str], Optional[Any]]``
-            invoked when JSON parsing fails. The callback should return a value to
-            yield instead of the raw chunk, or ``None`` to ignore.
     """
     if not isinstance(chunk, str):
         return None
@@ -128,11 +118,6 @@ def _decode_byte_stream(
             Defaults to 'replace'.
         buffer_size (int): The size of the internal buffer used for decoding.
 
-    Args:
-        byte_iterator: Iterator yielding bytes
-        encoding: Character encoding to use
-        errors: How to handle encoding errors ('strict', 'ignore', 'replace')
-        buffer_size: Size of internal buffer for performance tuning
     """
     # Initialize decoder with the specified encoding
     try:
@@ -252,7 +237,7 @@ def _sanitize_stream_sync(
     Args:
         data: String, iterable of strings, or iterable of bytes to process.
         intro_value: Prefix indicating the start of meaningful data.
-        to_json: Parse JSON content if ``True``.
+        to_json: Parse the chunk as JSON if True.
         skip_markers: Lines containing any of these markers are skipped.
         strip_chars: Characters to strip from each line.
         start_marker: Begin processing only after this marker is found.
@@ -611,10 +596,17 @@ async def _sanitize_stream_async(
 def sanitize_stream(
     data: Union[
         str,
+        bytes,
         Iterable[str],
         Iterable[bytes],
         AsyncIterable[str],
         AsyncIterable[bytes],
+        dict,
+        list,
+        int,
+        float,
+        bool,
+        None,
     ],
     intro_value: str = "data:",
     to_json: bool = True,
@@ -629,19 +621,16 @@ def sanitize_stream(
     buffer_size: int = 8192,
     line_delimiter: Optional[str] = None,
     error_handler: Optional[Callable[[Exception, str], Optional[Any]]] = None,
+    object_mode: Literal["as_is", "json", "str"] = "json",
+    raw: bool = False,
 ) -> Union[Generator[Any, None, None], AsyncGenerator[Any, None]]:
     """
     Processes streaming data (strings or bytes) in either synchronous or asynchronous mode.
-
-    This function acts as a unified interface for handling both synchronous and
-    asynchronous data streams. It automatically detects the type of input data and
-    dispatches it to the appropriate processing function (`_sanitize_stream_sync` or
-    `_sanitize_stream_async`).
+    Now supports non-iterable and miscellaneous input types (dict, list, int, float, bool, None).
 
     Args:
-        data (Union[str, Iterable[str], Iterable[bytes], AsyncIterable[str], AsyncIterable[bytes]]):
-            The data to be processed. Can be a string, a synchronous iterable of strings or bytes,
-            or an asynchronous iterable of strings or bytes.
+        data: The data to be processed. Can be a string, bytes, a synchronous iterable of strings or bytes,
+            an asynchronous iterable of strings or bytes, or a single object (dict, list, int, float, bool, None).
         intro_value (str): Prefix indicating the start of meaningful data. Defaults to "data:".
         to_json (bool): Parse JSON content if ``True``. Defaults to True.
         skip_markers (Optional[List[str]]): Lines containing any of these markers are skipped. Defaults to None.
@@ -659,34 +648,154 @@ def sanitize_stream(
         error_handler (Optional[Callable[[Exception, str], Optional[Any]]]):
             Callback invoked with ``(Exception, str)`` when JSON parsing fails.
             If the callback returns a value, it is yielded in place of the raw line. Defaults to None.
+        object_mode (Literal["as_is", "json", "str"]): How to handle non-string, non-iterable objects.
+            "json" (default) yields as JSON string, "str" yields as str(obj), "as_is" yields the object as-is.
+        raw (bool): If True, yields the raw response as returned by the API, chunk by chunk (no splitting or joining).
 
     Returns:
         Union[Generator[Any, None, None], AsyncGenerator[Any, None]]:
-            A generator or an asynchronous generator yielding the processed data.
-    """
-    # Determine the actual data payload to process
-    payload: Any  # The type of payload can change based on data's attributes
+            A generator or an asynchronous generator yielding the processed data, or raw data if raw=True.
+    """    # --- RAW MODE: yield each chunk exactly as returned by the API ---
+    if raw:
+        def _raw_passthrough_sync(source_iter):
+            for chunk in source_iter:
+                if isinstance(chunk, (bytes, bytearray)):
+                    # Decode bytes preserving all whitespace and newlines
+                    yield chunk.decode(encoding, encoding_errors)
+                elif chunk is not None:
+                    # Yield string chunks as-is, preserving all formatting
+                    yield chunk
+                # Skip None chunks entirely
+        async def _raw_passthrough_async(source_aiter):
+            async for chunk in source_aiter:
+                if isinstance(chunk, (bytes, bytearray)):
+                    # Decode bytes preserving all whitespace and newlines
+                    yield chunk.decode(encoding, encoding_errors)
+                elif chunk is not None:
+                    # Yield string chunks as-is, preserving all formatting
+                    yield chunk
+                # Skip None chunks entirely
+        # Sync iterable (but not str/bytes)
+        if hasattr(data, "__iter__") and not isinstance(data, (str, bytes)):
+            return _raw_passthrough_sync(data)
+        # Async iterable
+        if hasattr(data, "__aiter__"):
+            return _raw_passthrough_async(data)
+        # Single string or bytes
+        if isinstance(data, (bytes, bytearray)):
+            def _yield_single():
+                yield data.decode(encoding, encoding_errors)
+            return _yield_single()
+        else:
+            def _yield_single():
+                if data is not None:
+                    yield data
+            return _yield_single()
+    # --- END RAW MODE ---
 
     text_attr = getattr(data, "text", None)
     content_attr = getattr(data, "content", None)
 
+    # Handle None
+    if data is None:
+        def _empty_gen():
+            if False:
+                yield None
+        return _empty_gen()
+
+    # Handle bytes directly
+    if isinstance(data, bytes):
+        try:
+            payload = data.decode(encoding, encoding_errors)
+        except Exception:
+            payload = str(data)
+        return _sanitize_stream_sync(
+            payload, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+        )
+
+    # Handle string directly
+    if isinstance(data, str):
+        return _sanitize_stream_sync(
+            data, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+        )
+
+    # Handle dict, list, int, float, bool (non-iterable, non-string/bytes)
+    if isinstance(data, (dict, list, int, float, bool)):
+        if object_mode == "as_is":
+            def _as_is_gen():
+                yield data
+            return _as_is_gen()
+        elif object_mode == "str":
+            return _sanitize_stream_sync(
+                str(data), intro_value, to_json, skip_markers, strip_chars,
+                start_marker, end_marker, content_extractor, yield_raw_on_error,
+                encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            )
+        else:  # "json"
+            try:
+                json_str = json.dumps(data)
+            except Exception:
+                json_str = str(data)
+            return _sanitize_stream_sync(
+                json_str, intro_value, to_json, skip_markers, strip_chars,
+                start_marker, end_marker, content_extractor, yield_raw_on_error,
+                encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            )
+
+    # Handle file-like objects (optional, treat as string if .read exists)
+    if hasattr(data, "read") and callable(data.read):
+        try:
+            file_content = data.read()
+            if isinstance(file_content, bytes):
+                file_content = file_content.decode(encoding, encoding_errors)
+            return _sanitize_stream_sync(
+                file_content, intro_value, to_json, skip_markers, strip_chars,
+                start_marker, end_marker, content_extractor, yield_raw_on_error,
+                encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            )
+        except Exception:
+            pass  # fallback to next
+
+    # Handle .text or .content attributes
     if isinstance(text_attr, str):
         payload = text_attr
+        return _sanitize_stream_sync(
+            payload, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+        )
     elif isinstance(content_attr, bytes):
-        payload = content_attr.decode(encoding, encoding_errors)
-    else:
-        # Use the original data if .text or .content are not applicable or not found
-        payload = data
+        try:
+            payload = content_attr.decode(encoding, encoding_errors)
+        except Exception:
+            payload = str(content_attr)
+        return _sanitize_stream_sync(
+            payload, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+        )
 
-    # Dispatch to sync or async worker based on the nature of the 'payload'
-    if hasattr(payload, "__aiter__"):
+    # Handle async iterables
+    if hasattr(data, "__aiter__"):
         return _sanitize_stream_async(
-            payload, intro_value, to_json, skip_markers, strip_chars,
+            data, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+        )
+    # Handle sync iterables (but not strings/bytes)
+    if hasattr(data, "__iter__"):
+        return _sanitize_stream_sync(
+            data, intro_value, to_json, skip_markers, strip_chars,
             start_marker, end_marker, content_extractor, yield_raw_on_error,
             encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
         )
+    # Fallback: treat as string
     return _sanitize_stream_sync(
-        payload, intro_value, to_json, skip_markers, strip_chars,
+        str(data), intro_value, to_json, skip_markers, strip_chars,
         start_marker, end_marker, content_extractor, yield_raw_on_error,
         encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
     )

webscout/Bing_search.py

@@ -175,8 +175,7 @@ class BingSearch:
         url = self._first_page(keywords)['url']
         urls_to_fetch = [url]
         while len(fetched_results) < max_results and urls_to_fetch:
-            with self._executor as executor:
-                html_pages = list(executor.map(fetch_page, urls_to_fetch))
+            html_pages = list(self._executor.map(fetch_page, urls_to_fetch))
             urls_to_fetch = []
             for html in html_pages:
                 soup = BeautifulSoup(html, "html.parser")

webscout/Provider/AISEARCH/__init__.py

@@ -1,3 +1,4 @@
+from .stellar_search import *
 from .felo_search import *
 from .DeepFind import *
 from .genspark_search import *

webscout/Provider/AISEARCH/stellar_search.py

@@ -0,0 +1,132 @@
+import requests
+import re
+from typing import Dict, Optional, Generator, Union, Any
+from webscout.AIbase import AISearch, SearchResponse
+from webscout import exceptions
+from webscout.litagent import LitAgent
+from webscout.AIutel import sanitize_stream
+
+class Stellar(AISearch):
+    """AI Search provider for stellar.chatastra.ai"""
+    def __init__(self, timeout: int = 30, proxies: Optional[dict] = None):
+        self.api_endpoint = "https://stellar.chatastra.ai/search/x1GUVzl"
+        self.timeout = timeout
+        self.proxies = proxies
+        self.session = requests.Session()
+        self.headers = {
+            "accept": "text/x-component",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "content-type": "multipart/form-data; boundary=----WebKitFormBoundaryQsWD5Qs3QqDkNBPH",
+            "dnt": "1",
+            "next-action": "efc2643ed9bafe182a010b58ebea17f068ad3985",
+            "next-router-state-tree": "%5B%22%22%2C%7B%22children%22%3A%5B%22__PAGE__%22%2C%7B%7D%2C%22%2F%22%2C%22refresh%22%5D%7D%2Cnull%2Cnull%2Ctrue%5D",
+            "origin": "https://stellar.chatastra.ai",
+            "priority": "u=1, i",
+            "referer": "https://stellar.chatastra.ai/search/x1GUVzl",
+            "sec-ch-ua": '"Microsoft Edge";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "sec-gpc": "1",
+            "user-agent": LitAgent().random(),
+            "cookie": "__client_uat=0; __client_uat_K90aduOv=0",
+        }
+        self.session.headers.update(self.headers)
+        if proxies:
+            self.session.proxies = proxies
+
+    def _make_payload(self, prompt: str) -> bytes:        # This is a static payload for the demo; in production, generate dynamically as needed
+        boundary = "----WebKitFormBoundaryQsWD5Qs3QqDkNBPH"
+        parts = [
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"1\"\r\n\r\n{{\"id\":\"71bb616ba5b7cbcac2308fe0c249a9f2d51825b7\",\"bound\":null}}\r\n",
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"2\"\r\n\r\n{{\"id\":\"8bcca1d0cb933b14fefde88dacb2865be3d1d525\",\"bound\":null}}\r\n",
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"3_input\"\r\n\r\n{prompt}\r\n",
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"3_id\"\r\n\r\nx1GUVzl\r\n",
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"3_userId\"\r\n\r\nnull\r\n",
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"0\"\r\n\r\n[{{\"action\":\"$F1\",\"options\":{{\"onSetAIState\":\"$F2\"}}}},{{\"messages\":[],\"chatId\":\"\"}},\"$K3\"]\r\n",
+            f"--{boundary}--\r\n"
+        ]
+        return "".join(parts).encode("utf-8")
+
+    @staticmethod
+    def _stellar_extractor(chunk: Union[str, bytes, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the Stellar stream format with hex keys and diff arrays. Handles both str and bytes input."""
+        if isinstance(chunk, bytes):
+            try:
+                chunk = chunk.decode('utf-8', errors='replace')
+            except Exception:
+                return None
+        if not isinstance(chunk, str):
+            return None
+        # Match patterns like 6e:{"diff":[0," empathy"],"next":"$@6f"}
+        pattern = r'[0-9a-f]+:\{"diff":\[0,"([^"\\]*)"\]'
+        matches = re.findall(pattern, chunk)
+        if matches:
+            extracted_text = ''.join(matches)
+            # Fix escaped newlines
+            extracted_text = extracted_text.replace('\\n', '\n').replace('\\n\\n', '\n\n')
+            return extracted_text if extracted_text.strip() else None
+        return None
+
+    def search(self, prompt: str, stream: bool = False, raw: bool = False) -> Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse, str], None, None]]:
+        payload = self._make_payload(prompt)
+        try:
+            response = self.session.post(
+                self.api_endpoint,
+                data=payload,
+                timeout=self.timeout,
+                proxies=self.proxies,
+                stream=stream,
+            )
+            if not response.ok:
+                raise exceptions.APIConnectionError(f"Failed to get response: {response.status_code} {response.text}")
+
+            def _yield_stream():
+                # Use sanitize_stream for real-time extraction from the response iterator
+                processed_stream = sanitize_stream(
+                    data=response.iter_lines(decode_unicode=True),
+                    intro_value=None,
+                    to_json=False,
+                    content_extractor=self._stellar_extractor
+                )
+                full_response = ""
+                for content in processed_stream:
+                    if content and isinstance(content, str):
+                        full_response += content
+                        if raw:
+                            yield {"text": content}
+                        else:
+                            yield content
+                # Do NOT yield SearchResponse(full_response) in streaming mode to avoid duplicate output
+
+            if stream:
+                return _yield_stream()
+            else:
+                # Use sanitize_stream for the full response text
+                processed_stream = sanitize_stream(
+                    data=response.text.splitlines(),
+                    intro_value=None,
+                    to_json=False,
+                    content_extractor=self._stellar_extractor
+                )
+                full_response = ""
+                for content in processed_stream:
+                    if content and isinstance(content, str):
+                        full_response += content
+                if raw:
+                    return {"text": full_response}
+                else:
+                    return SearchResponse(full_response)
+        except requests.RequestException as e:
+            raise exceptions.APIConnectionError(f"Request failed: {e}")
+
+if __name__ == "__main__":
+    from rich import print
+    ai = Stellar()
+    user_query = input(">>> ")
+    response = ai.search(user_query, stream=True, raw=False)
+    for chunk in response:
+        print(chunk, end="", flush=True)

webscout/Provider/ExaChat.py

@@ -2,7 +2,7 @@ from curl_cffi import CurlError
 from curl_cffi.requests import Session, Response # Import Response
 import json
 import uuid
-from typing import Any, Dict, Union, Optional, List
+from typing import Any, Dict, Union, Optional, List, Generator
 from datetime import datetime
 from webscout.AIutel import Optimizers, Conversation, AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider 
@@ -264,10 +264,11 @@ class ExaChat(Provider):
     def ask(
         self,
         prompt: str,
+        stream: bool = False,
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> Union[Dict[str, Any], Generator[Any, None, None]]:
         """Sends a prompt to the API and returns the response."""
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -281,78 +282,103 @@ class ExaChat(Provider):
 
         payload = self._build_payload(conversation_prompt)
         response = self._make_request(payload)
-        
-        try:
+        processed_stream = sanitize_stream(
+            data=response.iter_content(chunk_size=None),
+            intro_value=None,
+            to_json=True,
+            content_extractor=self._exachat_extractor,
+            yield_raw_on_error=False,
+            raw=raw
+        )
+        if stream:
+            streaming_text = ""
+            for content_chunk in processed_stream:
+                if content_chunk and isinstance(content_chunk, str):
+                    content_chunk = content_chunk.replace('\\\\', '\\').replace('\\"', '"')
+                if raw:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                    yield content_chunk
+                else:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        yield dict(text=content_chunk)
+            self.last_response = {"text": streaming_text}
+            self.conversation.update_chat_history(prompt, streaming_text)
+        else:
             full_response = ""
-            # Use sanitize_stream to process the response
-            processed_stream = sanitize_stream(
-                data=response.iter_content(chunk_size=None), # Pass byte iterator
-                intro_value=None, # API doesn't seem to use 'data:' prefix
-                to_json=True,     # Stream sends JSON lines
-                content_extractor=self._exachat_extractor, # Use the specific extractor
-                yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
-            )
-
             for content_chunk in processed_stream:
-                # content_chunk is the string extracted by _exachat_extractor
                 if content_chunk and isinstance(content_chunk, str):
-                    full_response += content_chunk
-                            
+                    content_chunk = content_chunk.replace('\\\\', '\\').replace('\\"', '"')
+                if raw:
+                    if content_chunk and isinstance(content_chunk, str):
+                        full_response += content_chunk
+                else:
+                    if content_chunk and isinstance(content_chunk, str):
+                        full_response += content_chunk
             self.last_response = {"text": full_response}
             self.conversation.update_chat_history(prompt, full_response)
-            return self.last_response if not raw else full_response # Return dict or raw string
-            
-        except json.JSONDecodeError as e:
-            raise exceptions.FailedToGenerateResponseError(f"Invalid JSON response: {e}") from e
+            return self.last_response if not raw else full_response
 
     def chat(
         self,
         prompt: str,
+        stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-    ) -> str:
-        """Generate response."""
-        response = self.ask(
-            prompt, optimizer=optimizer, conversationally=conversationally
-        )
-        return self.get_message(response)
+        raw: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        def for_stream():
+            for response in self.ask(
+                prompt, stream=True, raw=raw, optimizer=optimizer, conversationally=conversationally
+            ):
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
+        def for_non_stream():
+            result = self.ask(
+                prompt, stream=False, raw=raw, optimizer=optimizer, conversationally=conversationally
+            )
+            if raw:
+                return result if isinstance(result, str) else str(result)
+            return self.get_message(result)
+        return for_stream() if stream else for_non_stream()
 
     def get_message(self, response: Union[Dict[str, Any], str]) -> str:
-        """
-        Retrieves message from response.
-        
-        Args:
-            response (Union[Dict[str, Any], str]): The response to extract the message from
-            
-        Returns:
-            str: The extracted message text
-        """
         if isinstance(response, dict):
-            return response.get("text", "")
-        return str(response)
+            text = response.get("text", "")
+        else:
+            text = str(response)
+        return text.replace('\\\\', '\\').replace('\\"', '"')
 
 if __name__ == "__main__":
-    print("-" * 80)
-    print(f"{'Model':<50} {'Status':<10} {'Response'}")
-    print("-" * 80)
+    # print("-" * 80)
+    # print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    # print("-" * 80)
     
-    # Test all available models
-    working = 0
-    total = len(ExaChat.AVAILABLE_MODELS)
+    # # Test all available models
+    # working = 0
+    # total = len(ExaChat.AVAILABLE_MODELS)
     
-    for model in ExaChat.AVAILABLE_MODELS:
-        try:
-            test_ai = ExaChat(model=model, timeout=60)
-            response = test_ai.chat("Say 'Hello' in one word")
-            response_text = response
+    # for model in ExaChat.AVAILABLE_MODELS:
+    #     try:
+    #         test_ai = ExaChat(model=model, timeout=60)
+    #         response = test_ai.chat("Say 'Hello' in one word")
+    #         response_text = response
             
-            if response_text and len(response_text.strip()) > 0:
-                status = "✓"
-                # Truncate response if too long
-                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
-            else:
-                status = "✗"
-                display_text = "Empty or invalid response"
-            print(f"{model:<50} {status:<10} {display_text}")
-        except Exception as e:
-            print(f"{model:<50} {'✗':<10} {str(e)}")
+    #         if response_text and len(response_text.strip()) > 0:
+    #             status = "✓"
+    #             # Truncate response if too long
+    #             display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+    #         else:
+    #             status = "✗"
+    #             display_text = "Empty or invalid response"
+    #         print(f"{model:<50} {status:<10} {display_text}")
+    #     except Exception as e:
+    #         print(f"{model:<50} {'✗':<10} {str(e)}")
+    from rich import print
+    ai = ExaChat(model="gemini-2.0-flash")
+    response = ai.chat("tell me a joke", stream=True, raw=False)
+    for chunk in response:
+        print(chunk, end='', flush=True)