webscout 8.2.3__py3-none-any.whl → 8.2.4__py3-none-any.whl

webscout/Provider/uncovr.py

@@ -1,4 +1,5 @@
-import requests
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
 import json
 import uuid
 import re
@@ -76,7 +77,9 @@ class UncovrAI(Provider):
             "Sec-Fetch-Site": "same-origin"
         }
         
-        self.session = requests.Session()
+        # Initialize curl_cffi Session
+        self.session = Session()
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
         self.session.proxies.update(proxies)
 
@@ -169,87 +172,124 @@ class UncovrAI(Provider):
 
         def for_stream():
             try:
-                with self.session.post(self.url, json=payload, stream=True, timeout=self.timeout) as response:
-                    if response.status_code != 200:
-                        # If we get a non-200 response, try refreshing our identity once
-                        if response.status_code in [403, 429]:
-                            self.refresh_identity()
-                            # Retry with new identity
-                            with self.session.post(self.url, json=payload, stream=True, timeout=self.timeout) as retry_response:
-                                if not retry_response.ok:
-                                    raise exceptions.FailedToGenerateResponseError(
-                                        f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
-                                    )
-                                response = retry_response
-                        else:
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.url, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate=self.fingerprint.get("browser_type", "chrome110") # Use fingerprint browser type
+                )
+                
+                if response.status_code != 200:
+                    # If we get a non-200 response, try refreshing our identity once
+                    if response.status_code in [403, 429]:
+                        self.refresh_identity()
+                        # Retry with new identity using curl_cffi session
+                        retry_response = self.session.post(
+                            self.url, 
+                            json=payload, 
+                            stream=True, 
+                            timeout=self.timeout,
+                            impersonate=self.fingerprint.get("browser_type", "chrome110") # Use updated fingerprint
+                        )
+                        if not retry_response.ok:
                             raise exceptions.FailedToGenerateResponseError(
-                                f"Request failed with status code {response.status_code}"
+                                f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
                             )
+                        response = retry_response # Use the successful retry response
+                    else:
+                        raise exceptions.FailedToGenerateResponseError(
+                            f"Request failed with status code {response.status_code} - {response.text}"
+                        )
+                
+                streaming_text = ""
+                # Iterate over bytes and decode manually
+                for line_bytes in response.iter_lines():
+                    if line_bytes:
+                        try:
+                            line = line_bytes.decode('utf-8')
+                            # Use regex to match content messages
+                            content_match = re.match(r'^0:\s*"?(.*?)"?$', line)
+                            if content_match:  # Content message
+                                content = content_match.group(1).encode().decode('unicode_escape') # Decode escapes
+                                streaming_text += content
+                                resp = dict(text=content)
+                                yield resp if raw else resp
+                            # Check for error messages
+                            error_match = re.match(r'^2:\[{"type":"error","error":"(.*?)"}]$', line)
+                            if error_match:
+                                error_msg = error_match.group(1)
+                                raise exceptions.FailedToGenerateResponseError(f"API Error: {error_msg}")
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            continue
+                
+                self.last_response = {"text": streaming_text}
+                self.conversation.update_chat_history(prompt, streaming_text)
                     
-                    streaming_text = ""
-                    for line in response.iter_lines():
-                        if line:
-                            try:
-                                line = line.decode('utf-8')
-                                # Use regex to match content messages
-                                content_match = re.match(r'^0:\s*"?(.*?)"?$', line)
-                                if content_match:  # Content message
-                                    content = content_match.group(1)
-                                    streaming_text += content
-                                    resp = dict(text=content)
-                                    yield resp if raw else resp
-                                # Check for error messages
-                                error_match = re.match(r'^2:\[{"type":"error","error":"(.*?)"}]$', line)
-                                if error_match:
-                                    error_msg = error_match.group(1)
-                                    raise exceptions.FailedToGenerateResponseError(f"API Error: {error_msg}")
-                            except (json.JSONDecodeError, UnicodeDecodeError):
-                                continue
-                    
-                    self.last_response = {"text": streaming_text}
-                    self.conversation.update_chat_history(prompt, streaming_text)
-                    
-            except requests.RequestException as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {str(e)}")
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
+
 
         def for_non_stream():
             try:
-                response = self.session.post(self.url, json=payload, timeout=self.timeout)
+                # Use curl_cffi session post with impersonate
+                response = self.session.post(
+                    self.url, 
+                    json=payload, 
+                    timeout=self.timeout,
+                    impersonate=self.fingerprint.get("browser_type", "chrome110")
+                )
+                
                 if response.status_code != 200:
                     if response.status_code in [403, 429]:
                         self.refresh_identity()
-                        response = self.session.post(self.url, json=payload, timeout=self.timeout)
+                        # Retry with new identity using curl_cffi session
+                        response = self.session.post(
+                            self.url, 
+                            json=payload, 
+                            timeout=self.timeout,
+                            impersonate=self.fingerprint.get("browser_type", "chrome110")
+                        )
                         if not response.ok:
                             raise exceptions.FailedToGenerateResponseError(
                                 f"Failed to generate response after identity refresh - ({response.status_code}, {response.reason}) - {response.text}"
                             )
                     else:
                         raise exceptions.FailedToGenerateResponseError(
-                            f"Request failed with status code {response.status_code}"
+                            f"Request failed with status code {response.status_code} - {response.text}"
                         )
 
+                # Process the non-streamed response content (assuming it's similar line format)
                 full_response = ""
-                for line in response.iter_lines():
+                # Use response.text which should contain the full body for non-streamed curl_cffi requests
+                for line in response.text.splitlines(): 
                     if line:
                         try:
-                            line = line.decode('utf-8')
+                            # line is already decoded string
                             content_match = re.match(r'^0:\s*"?(.*?)"?$', line)
                             if content_match:
-                                content = content_match.group(1)
+                                content = content_match.group(1).encode().decode('unicode_escape') # Decode escapes
                                 full_response += content
                             # Check for error messages
                             error_match = re.match(r'^2:\[{"type":"error","error":"(.*?)"}]$', line)
                             if error_match:
                                 error_msg = error_match.group(1)
                                 raise exceptions.FailedToGenerateResponseError(f"API Error: {error_msg}")
-                        except (json.JSONDecodeError, UnicodeDecodeError):
+                        except (json.JSONDecodeError): # UnicodeDecodeError less likely here
                             continue
 
                 self.last_response = {"text": full_response}
                 self.conversation.update_chat_history(prompt, full_response)
                 return {"text": full_response}
-            except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+                
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {e}")
+
 
         return for_stream() if stream else for_non_stream()
 
@@ -286,6 +326,7 @@ class UncovrAI(Provider):
         return response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
 
 if __name__ == "__main__":
+    # Ensure curl_cffi is installed
     print("-" * 80)
     print(f"{'Model':<50} {'Status':<10} {'Response'}")
     print("-" * 80)
@@ -293,20 +334,29 @@ if __name__ == "__main__":
     for model in UncovrAI.AVAILABLE_MODELS:
         try:
             test_ai = UncovrAI(model=model, timeout=60)
-            response = test_ai.chat("Say 'Hello' in one word", stream=True)
-            response_text = ""
-            for chunk in response:
-                response_text += chunk
+            # Test non-stream first as stream logic depends on it
+            response_non_stream = test_ai.chat("Say 'Hello' in one word", stream=False) 
             
-            if response_text and len(response_text.strip()) > 0:
-                status = "✓"
-                # Clean and truncate response
-                clean_text = response_text.strip().encode('utf-8', errors='ignore').decode('utf-8')
-                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
+            if response_non_stream and len(response_non_stream.strip()) > 0:
+                 # Now test stream
+                response_stream = test_ai.chat("Say 'Hi' in one word", stream=True)
+                response_text = ""
+                for chunk in response_stream:
+                    response_text += chunk
+                
+                if response_text and len(response_text.strip()) > 0:
+                    status = "✓"
+                    # Clean and truncate response
+                    clean_text = response_text.strip().encode('utf-8', errors='ignore').decode('utf-8')
+                    display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
+                else:
+                    status = "✗ (Stream)"
+                    display_text = "Empty or invalid stream response"
             else:
-                status = "✗"
-                display_text = "Empty or invalid response"
+                status = "✗ (Non-Stream)"
+                display_text = "Empty or invalid non-stream response"
+                
             print(f"\r{model:<50} {status:<10} {display_text}")
         except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}") 
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")
 

webscout/Provider/x0gpt.py

@@ -1,14 +1,17 @@
-from typing import Union, Any, Dict
+from typing import Optional, Union, Any, Dict
 from uuid import uuid4
-import requests
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
 import re
 
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
+# Import HTTPVersion enum
+from curl_cffi.const import CurlHttpVersion
 
 class X0GPT(Provider):
     """
@@ -60,7 +63,8 @@ class X0GPT(Provider):
             >>> print(ai.system_prompt)
             'You are a friendly assistant.'
         """
-        self.session = requests.Session()
+        # Initialize curl_cffi Session instead of requests.Session
+        self.session = Session() 
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.api_endpoint = "https://x0-gpt.devwtf.in/api/stream/reply"
@@ -77,18 +81,18 @@ class X0GPT(Provider):
             "path": "/api/stream/reply",
             "scheme": "https",
             "accept": "*/*",
-            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-encoding": "gzip, deflate, br, zstd", # Keep zstd for now
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "content-length": "114",
+            # "content-length": "114", # Let curl_cffi handle content-length
             "content-type": "application/json",
             "dnt": "1",
             "origin": "https://x0-gpt.devwtf.in",
-            "priority": "u=1, i",
+            # "priority": "u=1, i", # Remove priority header
             "referer": "https://x0-gpt.devwtf.in/chat",
             "sec-ch-ua": '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
             "sec-ch-ua-mobile": "?0",
             "sec-ch-ua-platform": '"Windows"',
-            "user-agent": self.agent.random()  # Use LitAgent to generate a random user agent
+            "user-agent": self.agent.random()
         }
 
         self.__available_optimizers = (
@@ -96,7 +100,10 @@ class X0GPT(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
+        # Update curl_cffi session headers and proxies
         self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
@@ -108,7 +115,17 @@ class X0GPT(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
-        self.session.proxies = proxies
+
+    @staticmethod
+    def _x0gpt_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from the x0gpt stream format '0:"..."'."""
+        if isinstance(chunk, str):
+            match = re.search(r'0:"(.*?)"', chunk)
+            if match:
+                # Decode potential unicode escapes like \u00e9
+                content = match.group(1).encode().decode('unicode_escape')
+                return content.replace('\\\\', '\\').replace('\\"', '"') # Handle escaped backslashes and quotes
+        return None
 
     def ask(
         self,
@@ -158,25 +175,48 @@ class X0GPT(Provider):
         }
 
         def for_stream():
-            response = self.session.post(self.api_endpoint, headers=self.headers, json=payload, stream=True, timeout=self.timeout)
-            if not response.ok:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+            try:
+                # Use curl_cffi session post with updated impersonate and http_version
+                response = self.session.post(
+                    self.api_endpoint,
+                    headers=self.headers,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    impersonate="chrome120", # Try a different impersonation profile
+                    http_version=CurlHttpVersion.V1_1 # Force HTTP/1.1
                 )
-            streaming_response = ""
-            for line in response.iter_lines(decode_unicode=True):
-                if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        streaming_response += content
-                        yield content if raw else dict(text=content)
-            self.last_response.update(dict(text=streaming_response))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                if not response.ok:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                    )
+                
+                streaming_response = ""
+                # Use sanitize_stream with the custom extractor
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    intro_value=None, # No simple prefix to remove here
+                    to_json=False,    # Content is not JSON
+                    content_extractor=self._x0gpt_extractor # Use the specific extractor
+                )
+
+                for content_chunk in processed_stream:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_response += content_chunk
+                        yield content_chunk if raw else dict(text=content_chunk)
+
+                self.last_response.update(dict(text=streaming_response))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+            except CurlError as e: # Catch CurlError
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e: # Catch other potential exceptions
+                # Include the original exception type in the message for clarity
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
 
         def for_non_stream():
+            # This function implicitly uses the updated for_stream
             for _ in for_stream():
                 pass
             return self.last_response
@@ -245,7 +285,10 @@ class X0GPT(Provider):
             'Why did the scarecrow win an award? Because he was outstanding in his field!'
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
-        formatted_text = response["text"].replace('\\n', '\n').replace('\\n\\n', '\n\n')
+        # Ensure text exists before processing
+        text = response.get("text", "")
+        # Formatting is now mostly handled by the extractor, just return
+        formatted_text = text
         return formatted_text
 
 if __name__ == "__main__":

webscout/Provider/yep.py

@@ -1,11 +1,12 @@
 import uuid
-import cloudscraper
 import json
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
 
 from typing import Any, Dict, Optional, Generator, Union, List, TypeVar
 
 from webscout.AIutel import Optimizers
-from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
 from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
@@ -62,7 +63,8 @@ class YEPCHAT(Provider):
                 f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}"
             )
 
-        self.session = cloudscraper.create_scraper()
+        # Initialize curl_cffi Session instead of cloudscraper
+        self.session = Session() 
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.chat_endpoint = "https://api.yep.com/v1/chat/completions"
@@ -111,11 +113,10 @@ class YEPCHAT(Provider):
             is_conversation, self.max_tokens_to_sample, filepath, update_file, tools=tools
         )
         self.conversation.history_offset = history_offset
+        # Set consistent headers and proxies for the curl_cffi session
+        self.session.headers.update(self.headers)
         self.session.proxies = proxies
-        
-        # Set consistent headers for the scraper session
-        for header, value in self.headers.items():
-            self.session.headers[header] = value
+        # Note: curl_cffi handles cookies differently, passed directly in requests
 
     def refresh_identity(self, browser: str = None):
         """
@@ -137,10 +138,9 @@ class YEPCHAT(Provider):
         })
         
         # Update session headers
-        for header, value in self.headers.items():
-            self.session.headers[header] = value
+        self.session.headers.update(self.headers)
         
-        # Generate new cookies
+        # Generate new cookies (will be passed in requests)
         self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
         
         return self.fingerprint
@@ -192,73 +192,82 @@ class YEPCHAT(Provider):
 
         def for_stream():
             try:
-                with self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout) as response:
-                    if not response.ok:
-                        # If we get a non-200 response, try refreshing our identity once
-                        if response.status_code in [403, 429]:
-                            self.refresh_identity()
-                            # Retry with new identity
-                            with self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout) as retry_response:
-                                if not retry_response.ok:
-                                    raise exceptions.FailedToGenerateResponseError(
-                                        f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
-                                    )
-                                response = retry_response
-                        else:
+                # buffer = b"" # No longer needed here
+                # Use curl_cffi session post, pass cookies explicitly
+                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                
+                if not response.ok:
+                    # If we get a non-200 response, try refreshing our identity once
+                    if response.status_code in [403, 429]:
+                        self.refresh_identity()
+                        # Retry with new identity
+                        # Use curl_cffi session post, pass cookies explicitly
+                        retry_response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                        if not retry_response.ok:
                             raise exceptions.FailedToGenerateResponseError(
-                                f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                                f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
                             )
+                        response = retry_response # Use the successful retry response
+                    else:
+                        raise exceptions.FailedToGenerateResponseError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
 
-                    streaming_text = ""
-                    for line in response.iter_lines(decode_unicode=True):
-                        if line:
-                            line = line.strip()
-                            if line.startswith("data: "):
-                                json_str = line[6:]
-                                if json_str == "[DONE]":
-                                    break
-                                try:
-                                    json_data = json.loads(json_str)
-                                    if 'choices' in json_data:
-                                        choice = json_data['choices'][0]
-                                        if 'delta' in choice and 'content' in choice['delta']:
-                                            content = choice['delta']['content']
-                                            streaming_text += content
-                                            
-                                            # Yield ONLY the new content:
-                                            resp = dict(text=content) 
-                                            yield resp if raw else resp
-                                except json.JSONDecodeError:
-                                    pass
-                    
-                    # Check if the response contains a tool call
-                    response_data = self.conversation.handle_tool_response(streaming_text)
-                    
-                    if response_data["is_tool_call"]:
-                        # Handle tool call results
-                        if response_data["success"]:
-                            for tool_call in response_data.get("tool_calls", []):
-                                tool_name = tool_call.get("name", "unknown_tool")
-                                result = response_data["result"]
-                                self.conversation.update_chat_history_with_tool(prompt, tool_name, result)
-                        else:
-                            # If tool call failed, update history with error
-                            self.conversation.update_chat_history(prompt, 
-                                f"Error executing tool call: {response_data['result']}")
+                # --- Start of stream processing block (should be outside the 'if not response.ok' block) ---
+                streaming_text = ""
+
+                # Use sanitize_stream to process the lines
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass the byte iterator directly
+                    intro_value="data:",
+                    to_json=True, # Yep sends JSON after 'data:'
+                    skip_markers=["[DONE]"], # Skip the final marker
+                    yield_raw_on_error=False, # Only process valid JSON data
+                    # --- Add the content extractor ---
+                    content_extractor=lambda chunk: chunk.get('choices', [{}])[0].get('delta', {}).get('content') if isinstance(chunk, dict) else None
+                )
+                # The loop now yields the final extracted string content directly
+                for content_chunk in processed_stream:
+                    # --- TEMPORARY DEBUG PRINT ---
+                    # print(f"\nDEBUG: Received extracted content: {content_chunk!r}\n", flush=True) # Keep or remove debug print as needed
+                    if content_chunk and isinstance(content_chunk, str): # Ensure it's a non-empty string
+                        streaming_text += content_chunk
+                        # Yield dict or raw string chunk based on 'raw' flag
+                        yield dict(text=content_chunk) if not raw else content_chunk
+                # --- End of stream processing block ---
+
+                # Check if the response contains a tool call (This should happen *after* processing the stream)
+                response_data = self.conversation.handle_tool_response(streaming_text)
+                
+                if response_data["is_tool_call"]:
+                    # Handle tool call results
+                    if response_data["success"]:
+                        for tool_call in response_data.get("tool_calls", []):
+                            tool_name = tool_call.get("name", "unknown_tool")
+                            result = response_data["result"]
+                            self.conversation.update_chat_history_with_tool(prompt, tool_name, result)
                     else:
-                        # Normal response handling
-                        self.conversation.update_chat_history(prompt, streaming_text)
+                        # If tool call failed, update history with error
+                        self.conversation.update_chat_history(prompt, 
+                            f"Error executing tool call: {response_data['result']}")
+                else:
+                    # Normal response handling
+                    self.conversation.update_chat_history(prompt, streaming_text)
                         
+            except CurlError as e: # Catch CurlError
+                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
             except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
 
         def for_non_stream():
             try:
-                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout)
+                # Use curl_cffi session post, pass cookies explicitly
+                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
                 if not response.ok:
                     if response.status_code in [403, 429]:
                         self.refresh_identity()
-                        response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout)
+                        # Use curl_cffi session post, pass cookies explicitly
+                        response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
                         if not response.ok:
                             raise exceptions.FailedToGenerateResponseError(
                                 f"Failed to generate response after identity refresh - ({response.status_code}, {response.reason}) - {response.text}"
@@ -268,6 +277,7 @@ class YEPCHAT(Provider):
                             f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                         )
 
+                # ... existing non-stream response handling code ...
                 response_data = response.json()
                 if 'choices' in response_data and len(response_data['choices']) > 0:
                     content = response_data['choices'][0].get('message', {}).get('content', '')
@@ -298,8 +308,10 @@ class YEPCHAT(Provider):
                         return {"text": content}
                 else:
                     raise exceptions.FailedToGenerateResponseError("No response content found")
+            except CurlError as e: # Catch CurlError
+                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
             except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed: e")
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
 
         return for_stream() if stream else for_non_stream()
 
@@ -373,4 +385,5 @@ if __name__ == "__main__":
                 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)}")
+            print(f"{model:<50} {'✗':<10} {str(e)}")
+