webscout 8.3.5__py3-none-any.whl → 8.3.7__py3-none-any.whl

webscout/Provider/scira_chat.py

@@ -16,52 +16,18 @@ class SciraAI(Provider):
     """
     A class to interact with the Scira AI chat API.
     """
-
+    required_auth = False
     # Model mapping: actual model names to Scira API format
     MODEL_MAPPING = {
         "grok-3-mini": "scira-default",
-        "grok-3-mini-fast": "scira-x-fast-mini",
-        "grok-3-fast": "scira-x-fast",
-        "gpt-4.1-nano": "scira-nano",
-        "grok-3": "scira-grok-3",
-        "grok-4": "scira-grok-4",
-        "grok-2-vision-1212": "scira-vision",
-        "grok-2-latest": "scira-g2",
-        "gpt-4o-mini": "scira-4o-mini",
-        "o4-mini-2025-04-16": "scira-o4-mini",
-        "o3": "scira-o3",
-        "qwen/qwen3-32b": "scira-qwen-32b",
-        "qwen3-30b-a3b": "scira-qwen-30b",
-        "deepseek-v3-0324": "scira-deepseek-v3",
-        "claude-3-5-haiku-20241022": "scira-haiku",
-        "mistral-small-latest": "scira-mistral",
-        "gemini-2.5-flash-lite-preview-06-17": "scira-google-lite",
-        "gemini-2.5-flash": "scira-google",
-        "gemini-2.5-pro": "scira-google-pro",
-        "claude-sonnet-4-20250514": "scira-anthropic",
-        "claude-sonnet-4-20250514-thinking": "scira-anthropic-thinking",
-        "claude-4-opus-20250514": "scira-opus",
-        "claude-4-opus-20250514-pro": "scira-opus-pro",
-        "meta-llama/llama-4-maverick-17b-128e-instruct": "scira-llama-4",
-        "kimi-k2-instruct": "scira-kimi-k2",
-        "scira-kimi-k2": "kimi-k2-instruct",
+        "llama-4-maverick": "scira-llama-4",
+        "qwen3-4b": "scira-qwen-4b",
+        "qwen3-32b": "scira-qwen-32b",
+        "qwen3-4b-thinking": "scira-qwen-4b-thinking",
     }
     
     # Reverse mapping: Scira format to actual model names
     SCIRA_TO_MODEL = {v: k for k, v in MODEL_MAPPING.items()}
-    # Add special cases for aliases and duplicate mappings
-    SCIRA_TO_MODEL["scira-anthropic-thinking"] = "claude-sonnet-4-20250514"
-    SCIRA_TO_MODEL["scira-opus-pro"] = "claude-4-opus-20250514"
-    SCIRA_TO_MODEL["scira-x-fast"] = "grok-3-fast"
-    SCIRA_TO_MODEL["scira-x-fast-mini"] = "grok-3-mini-fast"
-    SCIRA_TO_MODEL["scira-nano"] = "gpt-4.1-nano"
-    SCIRA_TO_MODEL["scira-qwen-32b"] = "qwen/qwen3-32b"
-    SCIRA_TO_MODEL["scira-qwen-30b"] = "qwen3-30b-a3b"
-    SCIRA_TO_MODEL["scira-deepseek-v3"] = "deepseek-v3-0324"
-    SCIRA_TO_MODEL["scira-grok-4"] = "grok-4"
-    SCIRA_TO_MODEL["scira-kimi-k2"] = "kimi-k2-instruct"
-    SCIRA_TO_MODEL["kimi-k2-instruct"] = "scira-kimi-k2"
-    MODEL_MAPPING["claude-4-opus-20250514-pro"] = "scira-opus-pro"
     # Available models list (actual model names + scira aliases)
     AVAILABLE_MODELS = list(MODEL_MAPPING.keys()) + list(SCIRA_TO_MODEL.keys())
     
@@ -139,19 +105,21 @@ class SciraAI(Provider):
         
         # Use the fingerprint for headers
         self.headers = {
-            "Accept": self.fingerprint["accept"],
+            "Accept": "*/*",
             "Accept-Encoding": "gzip, deflate, br, zstd",
-            "Accept-Language": self.fingerprint["accept_language"],
+            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
             "Content-Type": "application/json",
             "Origin": "https://scira.ai",
             "Referer": "https://scira.ai/",
-            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "Sec-CH-UA": '"Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"',
             "Sec-CH-UA-Mobile": "?0",
-            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
-            "User-Agent": self.fingerprint["user_agent"],
+            "Sec-CH-UA-Platform": '"Windows"',
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
             "Sec-Fetch-Dest": "empty",
             "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin"
+            "Sec-Fetch-Site": "same-origin",
+            "DNT": "1",
+            "Priority": "u=1, i"
         }
 
         self.session = Session() # Use curl_cffi Session
@@ -196,13 +164,13 @@ class SciraAI(Provider):
         browser = browser or self.fingerprint.get("browser_type", "chrome")
         self.fingerprint = self.agent.generate_fingerprint(browser)
 
-        # Update headers with new fingerprint
+        # Update headers with new fingerprint (keeping the updated values)
         self.headers.update({
-            "Accept": self.fingerprint["accept"],
-            "Accept-Language": self.fingerprint["accept_language"],
-            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or self.headers["Sec-CH-UA"],
-            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
-            "User-Agent": self.fingerprint["user_agent"],
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "Sec-CH-UA": '"Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"',
+            "Sec-CH-UA-Platform": '"Windows"',
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
         })
 
         # Update session headers
@@ -213,19 +181,18 @@ class SciraAI(Provider):
 
     @staticmethod
     def _scira_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[dict]:
-        """Extracts g and 0 chunks from the Scira stream format.
-        Returns a dict: {"g": [g1, g2, ...], "0": zero} if present.
+        """Extracts JSON chunks from the Scira stream format.
+        Returns a dict with the parsed JSON data.
         """
         if isinstance(chunk, str):
-            g_matches = re.findall(r'g:"(.*?)"', chunk)
-            zero_match = re.search(r'0:"(.*?)"(?=,|$)', chunk)
-            result = {}
-            if g_matches:
-                result["g"] = [g.encode().decode('unicode_escape').replace('\\', '\\').replace('\\"', '"') for g in g_matches]
-            if zero_match:
-                result["0"] = zero_match.group(1).encode().decode('unicode_escape').replace('\\', '\\').replace('\\"', '"')
-            if result:
-                return result
+            if chunk.startswith("data: "):
+                json_str = chunk[6:].strip()  # Remove "data: " prefix
+                if json_str == "[DONE]":
+                    return {"type": "done"}
+                try:
+                    return json.loads(json_str)
+                except json.JSONDecodeError:
+                    return None
         return None
 
     def ask(
@@ -246,8 +213,7 @@ class SciraAI(Provider):
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
         messages = [
-            {"role": "system", "content": self.system_prompt},
-            {"role": "user", "content": conversation_prompt, "parts": [{"type": "text", "text": conversation_prompt}]}
+            {"role": "user", "content": conversation_prompt, "parts": [{"type": "text", "text": conversation_prompt}], "id": str(uuid.uuid4())[:16]}
         ]
 
         # Prepare the request payload
@@ -257,7 +223,9 @@ class SciraAI(Provider):
             "model": self.model,
             "group": self.search_mode,
             "user_id": self.user_id,
-            "timezone": "Asia/Calcutta"
+            "timezone": "Asia/Calcutta",
+            "isCustomInstructionsEnabled": False,
+            "searchProvider": "parallel"
         }
 
         def for_stream():
@@ -306,41 +274,37 @@ class SciraAI(Provider):
                     if content is None:
                         continue
                     if isinstance(content, dict):
-                        # Handle g chunks
-                        g_chunks = content.get("g", [])
-                        zero_chunk = content.get("0")
-                        if g_chunks:
+                        event_type = content.get("type")
+                        if event_type == "reasoning-start":
                             if not in_think:
                                 if raw:
                                     yield "<think>\n\n"
                                 else:
                                     yield "<think>\n\n"
                                 in_think = True
-                            for g in g_chunks:
+                        elif event_type == "reasoning-delta":
+                            if in_think:
+                                delta = content.get("delta", "")
                                 if raw:
-                                    yield g
+                                    yield delta
                                 else:
-                                    yield dict(text=g)
-                        if zero_chunk is not None:
+                                    yield dict(text=delta)
+                        elif event_type == "reasoning-end":
                             if in_think:
                                 if raw:
                                     yield "</think>\n\n"
                                 else:
                                     yield "</think>\n\n"
                                 in_think = False
+                        elif event_type == "text-delta":
+                            delta = content.get("delta", "")
                             if raw:
-                                yield zero_chunk
+                                yield delta
                             else:
-                                streaming_response += zero_chunk
-                                yield dict(text=zero_chunk)
-                    else:
-                        # fallback for old string/list logic
-                        if raw:
-                            yield content
-                        else:
-                            if content and isinstance(content, str):
-                                streaming_response += content
-                                yield dict(text=content)
+                                streaming_response += delta
+                                yield dict(text=delta)
+                        elif event_type == "done":
+                            break  # End of stream
                 if not raw:
                     self.last_response = {"text": streaming_response}
                     self.conversation.update_chat_history(prompt, streaming_response)
@@ -415,43 +379,6 @@ class SciraAI(Provider):
         return response.get("text", "")
 
 if __name__ == "__main__":
-    print("-" * 80)
-    print(f"{'Model':<50} {'Status':<10} {'Response'}")
-    print("-" * 80)
-    
-    # Test all available models
-    working = 0
-    total = len(SciraAI.AVAILABLE_MODELS)
-    
-    for model in SciraAI.AVAILABLE_MODELS:
-        try:
-            test_ai = SciraAI(model=model, timeout=60)
-            # Test stream first
-            response_stream = test_ai.chat("Say 'Hello' in one word", stream=True)
-            response_text = ""
-            print(f"\r{model:<50} {'Streaming...':<10}", end="", flush=True)
-            for chunk in response_stream:
-                response_text += chunk
-                # Optional: print chunks as they arrive for visual feedback
-                # print(chunk, end="", flush=True) 
-            
-            if response_text and len(response_text.strip()) > 0:
-                status = "✓"
-                # Clean and truncate response
-                clean_text = response_text.strip() # Already decoded in get_message
-                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
-            else:
-                status = "✗ (Stream)"
-                display_text = "Empty or invalid stream response"
-            print(f"\r{model:<50} {status:<10} {display_text}")
-            
-            # Optional: Add non-stream test if needed, but stream test covers basic functionality
-            # print(f"\r{model:<50} {'Non-Stream...':<10}", end="", flush=True)
-            # response_non_stream = test_ai.chat("Say 'Hi' again", stream=False)
-            # if not response_non_stream or len(response_non_stream.strip()) == 0:
-            #      print(f"\r{model:<50} {'✗ (Non-Stream)':<10} Empty non-stream response")
-
-
-        except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}")
-
+    ai = SciraAI(model="grok-3-mini", is_conversation=True, system_prompt="You are a helpful assistant.")
+    for resp in ai.chat("Explain the theory of relativity in simple terms.", stream=True, raw=False):
+        print(resp, end="", flush=True)

webscout/Provider/searchchat.py

@@ -15,6 +15,7 @@ class SearchChatAI(Provider):
     """
     A class to interact with the SearchChatAI API.
     """
+    required_auth = False
     AVAILABLE_MODELS = ["gpt-4o-mini-2024-07-18"]
     def __init__(
         self,

webscout/Provider/sonus.py

@@ -12,7 +12,7 @@ class SonusAI(Provider):
     """
     A class to interact with the Sonus AI chat API.
     """
-
+    required_auth = False
     AVAILABLE_MODELS = [
         "pro",
         "air",

webscout/Provider/toolbaz.py

@@ -21,29 +21,33 @@ class Toolbaz(Provider):
     A class to interact with the Toolbaz API. Supports streaming responses.
     """
 
+    required_auth = False
     AVAILABLE_MODELS = [
         "gemini-2.5-flash",
+        "gemini-2.5-pro",
         "gemini-2.0-flash-thinking",
-        "sonar",
         "gemini-2.0-flash",
-        "gemini-1.5-flash",
+
+        "claude-sonnet-4",
+
+        "gpt-5",
+        "gpt-oss-120b",
         "o3-mini",
         "gpt-4o-latest",
-        "gpt-4o",
+
+        "toolbaz_v4",
+        "toolbaz_v3.5_pro",
+
         "deepseek-r1",
+        "deepseek-v3.1",
+        "deepseek-v3",
+
         "Llama-4-Maverick",
-        "Llama-4-Scout",
         "Llama-3.3-70B",
-        "Qwen2.5-72B",
-        "grok-2-1212",
-        "grok-3-beta",
-        "toolbaz_v3",
-        "toolbaz_v3.5_pro",
-        "toolbaz_v4",
+        
         "mixtral_8x22b",
         "L3-70B-Euryale-v2.1",
         "midnight-rose",
-        "unity",
         "unfiltered_x"
     ]
 

webscout/Provider/turboseek.py

@@ -1,19 +1,21 @@
+
+import re
+from typing import Optional, Union, Any, AsyncGenerator, Dict
 from curl_cffi.requests import Session
 from curl_cffi import CurlError
-import json
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
 from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
-from typing import Optional, Union, Any, AsyncGenerator, Dict
 from webscout.litagent import LitAgent
 
 class TurboSeek(Provider):
     """
     This class provides methods for interacting with the TurboSeek API.
     """
+    required_auth = False
     AVAILABLE_MODELS = ["Llama 3.1 70B"]
 
     def __init__(
@@ -58,13 +60,14 @@ class TurboSeek(Provider):
             "dnt": "1",
             "origin": "https://www.turboseek.io",
             "priority": "u=1, i",
-            "referer": "https://www.turboseek.io/?ref=taaft&utm_source=taaft&utm_medium=referral",
-            "sec-ch-ua": '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "referer": "https://www.turboseek.io/",
+            "sec-ch-ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"',
             "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(),
         }
 
@@ -88,11 +91,27 @@ class TurboSeek(Provider):
         )
         self.conversation.history_offset = history_offset
 
+    @staticmethod
+    def _strip_html_tags(text: str) -> str:
+        """Remove HTML tags from text."""
+        import re
+        # Remove HTML tags and entities
+        text = re.sub(r'<[^>]*>', '', text)
+        text = re.sub(r'&[^;]+;', ' ', text)
+        text = re.sub(r'\s+', ' ', text).strip()
+        return text
+
     @staticmethod
     def _turboseek_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
         """Extracts content from TurboSeek stream JSON objects."""
         if isinstance(chunk, dict) and "text" in chunk:
-            return chunk.get("text") # json.loads already handles unicode escapes
+            text = chunk.get("text")
+            if text:
+                # Clean HTML tags from the response
+                return TurboSeek._strip_html_tags(str(text))
+        elif isinstance(chunk, str):
+            # Handle raw string content
+            return TurboSeek._strip_html_tags(chunk)
         return None
 
     def ask(
@@ -155,7 +174,9 @@ class TurboSeek(Provider):
                     to_json=True,
                     content_extractor=self._turboseek_extractor,
                     yield_raw_on_error=False,
-                    raw=raw
+                    raw=raw,
+                    extract_regexes=[r'<[^>]*>([^<]*)<[^>]*>', r'([^<]+)'],
+                    skip_regexes=[r'<script[^>]*>.*?</script>', r'<style[^>]*>.*?</style>']
                 )
                 for content_chunk in processed_stream:
                     if isinstance(content_chunk, bytes):
@@ -247,19 +268,7 @@ class TurboSeek(Provider):
 if __name__ == '__main__':
     # Ensure curl_cffi is installed
     from rich import print
-    try: # Add try-except block for testing
-        ai = TurboSeek(timeout=60)
-        print("[bold blue]Testing Stream:[/bold blue]")
-        response_stream = ai.chat("yooooooooooo", stream=True, raw=False)
-        for chunk in response_stream:
-            print(chunk, end="", flush=True)
-        # Optional: Test non-stream
-        # print("[bold blue]Testing Non-Stream:[/bold blue]")
-        # response_non_stream = ai.chat("What is the capital of France?", stream=False)
-        # print(response_non_stream)
-        # print("[bold green]Non-Stream Test Complete.[/bold green]")
-
-    except exceptions.FailedToGenerateResponseError as e:
-        print(f"\n[bold red]API Error:[/bold red] {e}")
-    except Exception as e:
-        print(f"\n[bold red]An unexpected error occurred:[/bold red] {e}")
+    ai = TurboSeek(timeout=60)
+    response_stream = ai.chat("How can I get a 6 pack in 3 months?", stream=True, raw=False)
+    for chunk in response_stream:
+        print(chunk, end="", flush=True)

webscout/Provider/typefully.py

@@ -12,6 +12,7 @@ from curl_cffi.requests import Session
 from curl_cffi import CurlError
 
 class TypefullyAI(Provider):
+    required_auth = False
     AVAILABLE_MODELS = ["openai:gpt-4o-mini", "openai:gpt-4o", "anthropic:claude-3-5-haiku-20241022", "groq:llama-3.3-70b-versatile"]
 
     def __init__(
@@ -204,4 +205,4 @@ if __name__ == "__main__":
                 display_text = "Empty or invalid stream response"
             print(f"\r{model:<50} {status:<10} {display_text}")
         except Exception as e:
-            print(f"\r{model:<50} {'FAIL':<10} {str(e)}")
+            print(f"\r{model:<50} {'FAIL':<10} {str(e)}")

webscout/Provider/x0gpt.py

@@ -27,6 +27,7 @@ class X0GPT(Provider):
         >>> print(response)
         'The weather today is sunny with a high of 75°F.'
     """
+    required_auth = False
     AVAILABLE_MODELS = ["UNKNOWN"]
 
     def __init__(

webscout/Provider/yep.py

@@ -21,6 +21,7 @@ class YEPCHAT(Provider):
         AVAILABLE_MODELS (list): List of available models for the provider.
     """
 
+    required_auth = False
     AVAILABLE_MODELS = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
 
     def __init__(
@@ -366,7 +367,7 @@ if __name__ == "__main__":
     #     except Exception as e:
     #         print(f"{model:<50} {'✗':<10} {str(e)}")
     ai = YEPCHAT(model="DeepSeek-R1-Distill-Qwen-32B", timeout=60)
-    response = ai.chat("Say 'Hello' in one word", raw=True, stream=True)
+    response = ai.chat("Say 'Hello' in one word", raw=False, stream=True)
     for chunk in response:
 
         print(chunk, end='', flush=True)

webscout/conversation.py

@@ -165,29 +165,19 @@ class Conversation:
             ))
 
     def _compress_history(self) -> None:
-        """Compress history when it exceeds threshold."""
+        """Delete old history when it exceeds threshold."""
         if len(self.messages) > self.compression_threshold:
-            # Keep recent messages and summarize older ones
-            keep_recent = 100  # Adjust based on needs
-            self.messages = (
-                [self._summarize_messages(self.messages[:-keep_recent])] +
-                self.messages[-keep_recent:]
-            )
-
-    def _summarize_messages(self, messages: List[Message]) -> Message:
-        """Create a summary message from older messages."""
-        return Message(
-            role="system",
-            content="[History Summary] Previous conversation summarized for context",
-            metadata={"summarized_count": len(messages)}
-        )
+            # Remove oldest messages, keep only the most recent ones
+            self.messages = self.messages[-self.compression_threshold:]
+
+    # _summarize_messages removed
 
     def gen_complete_prompt(self, prompt: str, intro: Optional[str] = None) -> str:
         """Generate complete prompt with enhanced context management."""
         if not self.status:
             return prompt
 
-        intro = intro or self.intro
+        intro = intro or self.intro or ""
         
         # Add tool information if available
         tools_description = self.get_tools_description()
@@ -260,6 +250,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
 
     def _trim_chat_history(self, chat_history: str, intro: str) -> str:
         """Trim chat history with improved token management."""
+        intro = intro or ""
         total_length = len(intro) + len(chat_history)
         
         if total_length > self.history_offset:
@@ -273,20 +264,31 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         return chat_history
 
     def add_message(self, role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None:
-        """Add a message with enhanced validation and metadata support."""
+        """Add a message with enhanced validation and metadata support. Deletes oldest messages if total word count exceeds max_tokens_to_sample."""
         try:
             role = role.lower()  # Normalize role to lowercase
             if not self.validate_message(role, content):
                 raise MessageValidationError("Invalid message role or content")
 
+            # Calculate total word count in history
+            def total_word_count(messages):
+                return sum(len(msg.content.split()) for msg in messages)
+
+            # Remove oldest messages until total word count is below limit
+            temp_messages = self.messages.copy()
+            while temp_messages and (total_word_count(temp_messages) + len(content.split()) > self.max_tokens_to_sample):
+                temp_messages.pop(0)
+
+            self.messages = temp_messages
+
             message = Message(role=role, content=content, metadata=metadata or {})
             self.messages.append(message)
-            
+
             if self.file and self.update_file:
                 self._append_to_file(message)
-            
+
             self._compress_history()
-            
+
         except Exception as e:
             raise ConversationError(f"Failed to add message: {str(e)}") from e
 

webscout/sanitize.py

@@ -143,7 +143,7 @@ def _process_chunk(
     if to_json:
         try:
             # Only strip before JSON parsing if both boundaries are incorrect
-            if sanitized_chunk[0] not in '{[' and sanitized_chunk[-1] not in '}]':
+            if len(sanitized_chunk) >= 2 and sanitized_chunk[0] not in '{[' and sanitized_chunk[-1] not in '}]':
                 sanitized_chunk = sanitized_chunk.strip()
             return json.loads(sanitized_chunk)
         except (json.JSONDecodeError, Exception) as e:
@@ -646,13 +646,14 @@ async def _sanitize_stream_async(
             f"Stream must yield strings or bytes, not {type(first_item).__name__}"
         )
 
-    async for line in line_iterator:
-        if not line:
-            continue
-        buffer += line
-        while True:
-            if not found_start and start_marker:
-                idx = buffer.find(start_marker)
+    try:
+        async for line in line_iterator:
+            if not line:
+                continue
+            buffer += line
+            while True:
+                if not found_start and start_marker:
+                    idx = buffer.find(start_marker)
                 if idx != -1:
                     found_start = True
                     buffer = buffer[idx + len(start_marker) :]
@@ -735,6 +736,9 @@ async def _sanitize_stream_async(
                 break
             else:
                 break
+    except Exception as e:
+        import sys
+        print(f"Async stream processing error: {str(e)}", file=sys.stderr)
 
 
 def sanitize_stream(
@@ -937,7 +941,7 @@ def sanitize_stream(
             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,
-            skip_regexes, extract_regexes,
+            skip_regexes, extract_regexes, raw,
         )
 
     # Handle async iterables
@@ -966,6 +970,7 @@ def sanitize_stream(
 
 # --- Decorator version of sanitize_stream ---
 import functools
+import asyncio
 from typing import overload
 
 def _sanitize_stream_decorator(
@@ -1057,7 +1062,6 @@ sanitize_stream_decorator = _sanitize_stream_decorator
 lit_streamer = _sanitize_stream_decorator
 
 # Allow @sanitize_stream and @lit_streamer as decorators
-import asyncio
 sanitize_stream.__decorator__ = _sanitize_stream_decorator
 LITSTREAM.__decorator__ = _sanitize_stream_decorator
 lit_streamer.__decorator__ = _sanitize_stream_decorator