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

webscout/Provider/LambdaChat.py

@@ -93,49 +93,49 @@ class LambdaChat(Provider):
         self.session.proxies = proxies # Assign proxies directly
 
     def create_conversation(self, model: str):
-        """Create a new conversation with the specified model."""
+        """Create a new conversation with the specified model, using updated headers and cookies."""
         url = f"{self.url}/conversation"
         payload = {
             "model": model,
-            "preprompt": self.system_prompt,
-
+            "preprompt": self.system_prompt
         }
-        
-        # Update referer for this specific request
+
+        # Update headers for this specific request
         headers = self.headers.copy()
-        headers["Referer"] = f"{self.url}/models/{model}"
-        
+        headers["Referer"] = f"{self.url}/"
+        # Add browser-like headers for best compatibility
+        headers["Accept-Encoding"] = "gzip, deflate, br, zstd"
+        headers["Accept-Language"] = "en-US,en;q=0.9,en-IN;q=0.8"
+        headers["Sec-GPC"] = "1"
+        headers["Sec-Ch-Ua"] = '"Not)A;Brand";v="8", "Chromium";v="138", "Microsoft Edge";v="138"'
+        headers["Sec-Ch-Ua-Mobile"] = "?0"
+        headers["Sec-Ch-Ua-Platform"] = '"Windows"'
+        headers["User-Agent"] = LitAgent().random() # Use LitAgent for User-Agent
+        headers["Origin"] = self.url
+        # cookies are handled by curl_cffi session automatically
+
         try:
-            # Use curl_cffi session post with impersonate
             response = self.session.post(
-                url, 
-                json=payload, 
-                headers=headers, # Use updated headers with specific Referer
-                impersonate="chrome110" # Use a common impersonation profile
+                url,
+                json=payload,
+                headers=headers,
+                impersonate="chrome110"
             )
-            
             if response.status_code == 401:
                 raise exceptions.AuthenticationError("Authentication failed.")
-            
-            # Handle other error codes
             if response.status_code != 200:
                 return None
-                
             data = response.json()
             conversation_id = data.get("conversationId")
-            
-            # Store conversation data
             if model not in self._conversation_data:
                 self._conversation_data[model] = {
                     "conversationId": conversation_id,
-                    "messageId": str(uuid.uuid4())  # Initial message ID
+                    "messageId": str(uuid.uuid4())
                 }
-                
             return conversation_id
-        except CurlError as e: # Catch CurlError
-            # Log or handle CurlError specifically if needed
+        except CurlError:
             return None
-        except Exception: # Catch other potential exceptions (like JSONDecodeError, HTTPError)
+        except Exception:
             return None
     
     def fetch_message_id(self, conversation_id: str) -> str:
@@ -230,35 +230,43 @@ class LambdaChat(Provider):
         url = f"{self.url}/conversation/{conversation_id}"
         message_id = self._conversation_data[model]["messageId"]
         
-        # Data to send
+        # Data to send (tools should be empty list by default)
         request_data = {
             "inputs": prompt,
             "id": message_id,
             "is_retry": False,
             "is_continue": False,
             "web_search": web_search,
-            "tools": ["66e85bb396d054c5771bc6cb", "00000000000000000000000a"]
+            "tools": []
         }
-        
+
         # Update headers for this specific request
         headers = self.headers.copy()
         headers["Referer"] = f"{self.url}/conversation/{conversation_id}"
-        
+        headers["Accept-Encoding"] = "gzip, deflate, br, zstd"
+        headers["Accept-Language"] = "en-US,en;q=0.9,en-IN;q=0.8"
+        headers["Sec-GPC"] = "1"
+        headers["Sec-Ch-Ua"] = '"Not)A;Brand";v="8", "Chromium";v="138", "Microsoft Edge";v="138"'
+        headers["Sec-Ch-Ua-Mobile"] = "?0"
+        headers["Sec-Ch-Ua-Platform"] = '"Windows"'
+        headers["User-Agent"] = LitAgent().random() # Use LitAgent for User-Agent
+        headers["Origin"] = self.url
+
         # Create multipart form data
         boundary = self.generate_boundary()
         multipart_headers = headers.copy()
         multipart_headers["Content-Type"] = f"multipart/form-data; boundary={boundary}"
-        
+
         # Serialize the data to JSON
         data_json = json.dumps(request_data, separators=(',', ':'))
-        
+
         # Create the multipart form data body
         body = f"--{boundary}\r\n"
         body += f'Content-Disposition: form-data; name="data"\r\n'
-        body += f"Content-Type: application/json\r\n\r\n"
+        body += f"\r\n"
         body += f"{data_json}\r\n"
         body += f"--{boundary}--\r\n"
-        
+
         multipart_headers["Content-Length"] = str(len(body))
         
         def for_stream():

webscout/Provider/Netwrck.py

@@ -14,23 +14,20 @@ class Netwrck(Provider):
     greeting = """Hello! I'm a helpful assistant. How can I help you today?"""
 
     AVAILABLE_MODELS = [
-        "neversleep/llama-3-lumimaid-8b:extended",
-        "x-ai/grok-2",
-        "anthropic/claude-3-7-sonnet-20250219",
+        "thedrummer/valkyrie-49b-v1",
         "sao10k/l3-euryale-70b",
+        "deepseek/deepseek-chat",
+        "deepseek/deepseek-r1",
+        "anthropic/claude-sonnet-4-20250514",
         "openai/gpt-4.1-mini",
         "gryphe/mythomax-l2-13b",
-        "google/gemini-pro-1.5",
         "google/gemini-2.5-flash-preview-04-17",
         "nvidia/llama-3.1-nemotron-70b-instruct",
-        "deepseek/deepseek-r1",
-        "deepseek/deepseek-chat"
-
     ]
 
     def __init__(
         self,
-        model: str = "anthropic/claude-3-7-sonnet-20250219",
+        model: str = "anthropic/claude-sonnet-4-20250514",
         is_conversation: bool = True,
         max_tokens: int = 4096, # Note: max_tokens is not used by this API
         timeout: int = 30,

webscout/Provider/OLLAMA.py

@@ -1,14 +1,13 @@
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream
-from webscout.AIbase import Provider, AsyncProvider
-from webscout import exceptions
-from typing import Any, AsyncGenerator, Dict, List, Optional, Union
-import ollama
-from ollama import AsyncClient, Client, ResponseError
-import asyncio
-import base64
-from pathlib import Path
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import Provider
+from typing import AsyncGenerator, Dict, List, Optional, Union
+
+try:
+    from ollama import AsyncClient, Client, ResponseError
+except ImportError as e:
+    pass
 
 class OLLAMA(Provider):
     def __init__(

webscout/Provider/OPENAI/README.md

@@ -39,7 +39,6 @@ Currently, the following providers are implemented with OpenAI-compatible interf
 - TypeGPT
 - SciraChat
 - LLMChatCo
-- FreeAIChat
 - YEPCHAT
 - HeckAI
 - SonusAI
@@ -73,6 +72,7 @@ Currently, the following providers are implemented with OpenAI-compatible interf
 - MonoChat
 - Friendli
 - MiniMax
+- QodoAI
 
 ## 💻 Usage Examples
 

webscout/Provider/OPENAI/TogetherAI.py

@@ -199,68 +199,77 @@ class Chat(BaseChat):
         self.completions = Completions(client)
 
 
-class TogetherAI(OpenAICompatibleProvider):
-    """
-    OpenAI-compatible client for TogetherAI API.
-    """
 class TogetherAI(OpenAICompatibleProvider):
     """
     OpenAI-compatible client for TogetherAI API.
     """
     AVAILABLE_MODELS = [
-        "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
-        "Qwen/QwQ-32B",
-        "Qwen/Qwen2-72B-Instruct",
-        "Qwen/Qwen2-VL-72B-Instruct",
-        "Qwen/Qwen2.5-72B-Instruct-Turbo",
+        "mistralai/Mistral-7B-Instruct-v0.3",
+        "togethercomputer/MoA-1",
         "Qwen/Qwen2.5-7B-Instruct-Turbo",
+        "meta-llama/Llama-3-8b-chat-hf",
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        "togethercomputer/MoA-1-Turbo",
+        "eddiehou/meta-llama/Llama-3.1-405B",
+        "mistralai/Mistral-7B-Instruct-v0.2",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+        "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3-70B-Instruct-Turbo",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
         "Qwen/Qwen2.5-VL-72B-Instruct",
-        "Qwen/Qwen3-235B-A22B-fp8-tput",
-        "Salesforce/Llama-Rank-V1",
-        "arcee-ai/arcee-blitz",
-        "arcee-ai/caller",
-        "arcee-ai/coder-large",
+        "arcee-ai/AFM-4.5B-Preview",
+        "lgai/exaone-3-5-32b-instruct",
+        "meta-llama/Llama-3-70b-chat-hf",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "google/gemma-2-27b-it",
+        "Qwen/Qwen2-72B-Instruct",
+        "mistralai/Mistral-Small-24B-Instruct-2501",
+        "Qwen/Qwen2-VL-72B-Instruct",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+        "meta-llama/Llama-Vision-Free",
+        "perplexity-ai/r1-1776",
+        "scb10x/scb10x-llama3-1-typhoon2-70b-instruct",
         "arcee-ai/maestro-reasoning",
-        "arcee-ai/virtuoso-large",
-        "arcee-ai/virtuoso-medium-v2",
+        "togethercomputer/Refuel-Llm-V2-Small",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "arcee-ai/coder-large",
+        "Qwen/QwQ-32B",
         "arcee_ai/arcee-spotlight",
-        "blackbox/meta-llama-3-1-8b",
-        "deepseek-ai/DeepSeek-R1",
-        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
-        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B-free",
-        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
-        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
-        "deepseek-ai/DeepSeek-V3",
-        "google/gemma-2-27b-it",
-        "lgai/exaone-3-5-32b-instruct",
-        "lgai/exaone-deep-32b",
+        "deepseek-ai/DeepSeek-R1-0528-tput",
         "marin-community/marin-8b-instruct",
-        "meta-llama-llama-2-70b-hf",
-        "meta-llama/Llama-2-70b-hf",
-        "meta-llama/Llama-3-8b-chat-hf",
-        "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
-        "meta-llama/Llama-3.2-3B-Instruct-Turbo",
-        "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo",
-        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+        "lgai/exaone-deep-32b",
+        "google/gemma-3-27b-it",
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+        "mistralai/Mistral-7B-Instruct-v0.1",
         "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
-        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
-        "meta-llama/Llama-Vision-Free",
-        "meta-llama/Meta-Llama-3-70B-Instruct-Turbo",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B-free",
+        "scb10x/scb10x-typhoon-2-1-gemma3-12b",
+        "togethercomputer/Refuel-Llm-V2",
+        "Qwen/Qwen2.5-72B-Instruct-Turbo",
         "meta-llama/Meta-Llama-3-8B-Instruct-Lite",
-        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+        "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+        "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
+        "deepseek-ai/DeepSeek-V3",
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
         "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        "Qwen/Qwen3-32B-FP8",
+        "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo",
+        "arcee-ai/virtuoso-large",
+        "google/gemma-3n-E4B-it",
+        "moonshotai/Kimi-K2-Instruct",
         "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
-        "mistralai/Mistral-7B-Instruct-v0.1",
-        "mistralai/Mistral-7B-Instruct-v0.2",
-        "mistralai/Mistral-7B-Instruct-v0.3",
-        "mistralai/Mistral-Small-24B-Instruct-2501",
-        "mistralai/Mixtral-8x7B-Instruct-v0.1",
-        "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
-        "perplexity-ai/r1-1776",
-        "scb10x/scb10x-llama3-1-typhoon2-70b-instruct",
-        "scb10x/scb10x-typhoon-2-1-gemma3-12b",
-        "togethercomputer/Refuel-Llm-V2-Small",
+        "deepseek-ai/DeepSeek-R1",
+        "Qwen/Qwen3-235B-A22B-fp8-tput",
+        "Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
+        "Rrrr/nim/nvidia/llama-3.3-nemotron-super-49b-v1-de6a6453",
+        "Rrrr/mistralai/Devstral-Small-2505-306f5881",
+        "Qwen/Qwen3-235B-A22B-Thinking-2507",
+        "Rrrr/ChatGPT-5",
+        "Rrrr/MeowGPT-3.5",
+        "blackbox/meta-llama-3-1-8b"
     ]
 
     def __init__(self, browser: str = "chrome"):

webscout/Provider/OPENAI/TwoAI.py

@@ -5,6 +5,9 @@ import time
 import uuid
 import re
 import urllib.parse
+import os
+import pickle
+import tempfile
 from typing import List, Dict, Optional, Union, Generator, Any
 
 from webscout.Extra.tempmail import get_random_email
@@ -208,6 +211,96 @@ class TwoAI(OpenAICompatibleProvider):
     """OpenAI-compatible client for the TwoAI API."""
 
     AVAILABLE_MODELS = ["sutra-v2", "sutra-r0"]
+    
+    # Class-level cache for API keys
+    _api_key_cache = None
+    _cache_file = os.path.join(tempfile.gettempdir(), "webscout_twoai_openai_cache.pkl")
+
+    @classmethod
+    def _load_cached_api_key(cls) -> Optional[str]:
+        """Load cached API key from file."""
+        try:
+            if os.path.exists(cls._cache_file):
+                with open(cls._cache_file, 'rb') as f:
+                    cache_data = pickle.load(f)
+                    # Check if cache is not too old (24 hours)
+                    if time.time() - cache_data.get('timestamp', 0) < 86400:
+                        return cache_data.get('api_key')
+        except Exception:
+            # If cache is corrupted or unreadable, ignore and regenerate
+            pass
+        return None
+
+    @classmethod
+    def _save_cached_api_key(cls, api_key: str):
+        """Save API key to cache file."""
+        try:
+            cache_data = {
+                'api_key': api_key,
+                'timestamp': time.time()
+            }
+            with open(cls._cache_file, 'wb') as f:
+                pickle.dump(cache_data, f)
+        except Exception:
+            # If caching fails, continue without caching
+            pass
+
+    @classmethod
+    def _validate_api_key(cls, api_key: str) -> bool:
+        """Validate if an API key is still working."""
+        try:
+            session = Session()
+            headers = {
+                'User-Agent': LitAgent().random(),
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                'Authorization': f'Bearer {api_key}',
+            }
+            
+            # Test with a simple request
+            test_payload = {
+                "messages": [{"role": "user", "content": "test"}],
+                "model": "sutra-v2",
+                "max_tokens": 1,
+                "stream": False
+            }
+            
+            response = session.post(
+                "https://api.two.ai/v2/chat/completions",
+                headers=headers,
+                json=test_payload,
+                timeout=10,
+                impersonate="chrome120"
+            )
+            
+            # If we get a 200 or 400 (bad request but auth worked), key is valid
+            # If we get 401/403, key is invalid
+            return response.status_code not in [401, 403]
+        except Exception:
+            # If validation fails, assume key is invalid
+            return False
+
+    @classmethod
+    def get_cached_api_key(cls) -> str:
+        """Get a cached API key or generate a new one if needed."""
+        # First check class-level cache
+        if cls._api_key_cache:
+            if cls._validate_api_key(cls._api_key_cache):
+                return cls._api_key_cache
+            else:
+                cls._api_key_cache = None
+
+        # Then check file cache
+        cached_key = cls._load_cached_api_key()
+        if cached_key and cls._validate_api_key(cached_key):
+            cls._api_key_cache = cached_key
+            return cached_key
+
+        # Generate new key if no valid cached key
+        new_key = cls.generate_api_key()
+        cls._api_key_cache = new_key
+        cls._save_cached_api_key(new_key)
+        return new_key
 
     @staticmethod
     def generate_api_key() -> str:
@@ -302,7 +395,7 @@ class TwoAI(OpenAICompatibleProvider):
         return api_key
 
     def __init__(self, browser: str = "chrome"):
-        api_key = self.generate_api_key()
+        api_key = self.get_cached_api_key()
         self.timeout = 30
         self.base_url = "https://api.two.ai/v2/chat/completions"
         self.api_key = api_key

webscout/Provider/OPENAI/__init__.py

@@ -6,9 +6,7 @@ from .x0gpt import *
 from .wisecat import *
 from .venice import *
 from .exaai import *
-from .typegpt import *
 from .scirachat import *
-from .freeaichat import *
 from .llmchatco import *
 from .yep import * # Add YEPCHAT
 from .heckai import *
@@ -18,7 +16,6 @@ from .netwrck import *
 from .standardinput import *
 from .writecream import *
 from .toolbaz import *
-from .uncovrAI import *
 from .opkfc import *
 from .chatgpt import *
 from .textpollinations import *
@@ -46,6 +43,7 @@ from .GeminiProxy import *  # Add GeminiProxy provider
 from .friendli import *
 from .monochat import *
 from .MiniMax import *  # Add MiniMaxAI provider
+from .qodo import *  # Add QodoAI provider
 # Export auto-proxy functionality
 from .autoproxy import (
     get_auto_proxy,

webscout/Provider/OPENAI/autoproxy.py

@@ -32,7 +32,7 @@ _proxy_cache = {
     'cache_duration': 300  # 5 minutes
 }
 
-PROXY_SOURCE_URL = "http://207.180.209.185:5000/ips.txt"
+PROXY_SOURCE_URL = "https://proxies.typegpt.net/ips.txt"
 
 # --- Static Proxy Lists ---
 # NordVPN proxies (format: https://host:port:user:pass)

webscout/Provider/OPENAI/copilot.py

@@ -86,14 +86,8 @@ class Completions(BaseCompletions):
                     raise RuntimeError(f"Image upload failed: {r.text}")
                 images.append({"type": "image", "url": r.json().get("url")})
 
-            # Connect to websocket
-            # Note: ws_connect might not use timeout in the same way as POST/GET
             ws = s.ws_connect(self._client.websocket_url)
-
-            # Use model to set mode ("reasoning" for Think Deeper)
             mode = "reasoning" if "Think" in model else "chat"
-
-            # Send the message to Copilot
             ws.send(json.dumps({
                 "event": "send",
                 "conversationId": conv_id,
@@ -101,79 +95,132 @@ class Completions(BaseCompletions):
                 "mode": mode
             }).encode(), CurlWsFlag.TEXT)
 
-            # Track token usage using count_tokens
             prompt_tokens = count_tokens(prompt_text)
             completion_tokens = 0
             total_tokens = prompt_tokens
-
             started = False
+            image_prompt = None
             while True:
                 try:
                     msg = json.loads(ws.recv()[0])
                 except Exception:
                     break
 
-                if msg.get("event") == "appendText":
+                event = msg.get("event")
+                if event not in ["appendText", "done", "error", "generatingImage", "imageGenerated", "suggestedFollowups", "replaceText"]:
+                    print(f"[Copilot] Unhandled event: {event} | msg: {msg}")
+
+                if event == "appendText":
                     started = True
                     content = msg.get("text", "")
-                    
-                    # Update token counts using count_tokens
                     content_tokens = count_tokens(content)
                     completion_tokens += content_tokens
                     total_tokens = prompt_tokens + completion_tokens
-
-                    # Create the delta object
                     delta = ChoiceDelta(
                         content=content,
                         role="assistant"
                     )
-
-                    # Create the choice object
                     choice = Choice(
                         index=0,
                         delta=delta,
                         finish_reason=None
                     )
-
-                    # Create the chunk object
                     chunk = ChatCompletionChunk(
                         id=request_id,
                         choices=[choice],
                         created=created_time,
                         model=model
                     )
-
                     yield chunk
-                elif msg.get("event") == "done":
-                    # Final chunk with finish_reason
+                elif event == "replaceText":
+                    # treat as appendText for OpenAI compatibility
+                    content = msg.get("text", "")
+                    content_tokens = count_tokens(content)
+                    completion_tokens += content_tokens
+                    total_tokens = prompt_tokens + completion_tokens
+                    delta = ChoiceDelta(
+                        content=content,
+                        role="assistant"
+                    )
+                    choice = Choice(
+                        index=0,
+                        delta=delta,
+                        finish_reason=None
+                    )
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model
+                    )
+                    yield chunk
+                elif event == "generatingImage":
+                    image_prompt = msg.get("prompt")
+                elif event == "imageGenerated":
+                    # Yield a chunk with image metadata in the delta (custom extension)
+                    delta = ChoiceDelta(
+                        content=None,
+                        role=None
+                    )
+                    choice = Choice(
+                        index=0,
+                        delta=delta,
+                        finish_reason=None
+                    )
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model
+                    )
+                    chunk.image_url = msg.get("url")
+                    chunk.image_prompt = image_prompt
+                    chunk.image_preview = msg.get("thumbnailUrl")
+                    yield chunk
+                elif event == "suggestedFollowups":
+                    # Yield a chunk with followups in the delta (custom extension)
+                    delta = ChoiceDelta(
+                        content=None,
+                        role=None
+                    )
+                    choice = Choice(
+                        index=0,
+                        delta=delta,
+                        finish_reason=None
+                    )
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model
+                    )
+                    chunk.suggested_followups = msg.get("suggestions")
+                    yield chunk
+                elif event == "done":
                     delta = ChoiceDelta(
                         content=None,
                         role=None
                     )
-
                     choice = Choice(
                         index=0,
                         delta=delta,
                         finish_reason="stop"
                     )
-
                     chunk = ChatCompletionChunk(
                         id=request_id,
                         choices=[choice],
                         created=created_time,
                         model=model
                     )
-
                     yield chunk
                     break
-                elif msg.get("event") == "error":
+                elif event == "error":
+                    print(f"[Copilot] Error event: {msg}")
                     raise RuntimeError(f"Copilot error: {msg}")
 
             ws.close()
-
             if not started:
                 raise RuntimeError("No response received from Copilot")
-
         except Exception as e:
             raise RuntimeError(f"Stream error: {e}") from e
         finally: