webscout 8.2.6__py3-none-any.whl → 8.2.8__py3-none-any.whl

webscout/Provider/HeckAI.py

@@ -2,7 +2,6 @@ from curl_cffi.requests import Session
 from curl_cffi import CurlError
 import json
 import uuid
-import sys
 from typing import Any, Dict, Optional, Generator, Union
 
 from webscout.AIutel import Optimizers
@@ -25,7 +24,6 @@ class HeckAI(Provider):
         "openai/gpt-4.1-mini",
         "x-ai/grok-3-mini-beta",
         "meta-llama/llama-4-scout"
-
     ]
 
     def __init__(
@@ -112,7 +110,8 @@ class HeckAI(Provider):
             "sessionId": self.session_id,
             "previousQuestion": self.previous_question,
             "previousAnswer": self.previous_answer,
-            "imgUrls": []
+            "imgUrls": [],
+            "superSmartMode": False  # Added based on API request data
         }
         
         # Store this message as previous for next request
@@ -120,7 +119,6 @@ class HeckAI(Provider):
 
         def for_stream():
             streaming_text = "" # Initialize outside try block
-            # in_answer = False # No longer needed
             try:
                 # Use curl_cffi session post with impersonate
                 response = self.session.post(
@@ -134,15 +132,16 @@ class HeckAI(Provider):
                 response.raise_for_status() # Check for HTTP errors
 
                 # Use sanitize_stream to process the stream
-                processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None), # Pass byte iterator
-                    intro_value="data:",  # Prefix to remove *from lines between markers*
-                    to_json=False,        # Content is text
-                    start_marker="data: [ANSWER_START]", # Check against the raw line including prefix
-                    end_marker="data: [ANSWER_DONE]",     # Check against the raw line including prefix
-                    skip_markers=["[RELATE_Q_START]", "[RELATE_Q_DONE]"], # Skip these if they appear within answer block
-                    yield_raw_on_error=True
-                )
+                processed_stream = sanitize_stream(
+                data=response.iter_content(chunk_size=1024), # Pass byte iterator
+                intro_value="data: ",  # Prefix to remove (note the space)
+                to_json=False,        # Content is text
+                start_marker="data: [ANSWER_START]",
+                end_marker="data: [ANSWER_DONE]",
+                skip_markers=["data: [RELATE_Q_START]", "data: [RELATE_Q_DONE]", "data: [REASON_START]", "data: [REASON_DONE]"],
+                yield_raw_on_error=True,
+                strip_chars=" \n\r\t"  # Strip whitespace characters from chunks
+                )
 
                 for content_chunk in processed_stream:
                     # content_chunk is the text between ANSWER_START and ANSWER_DONE
@@ -150,9 +149,21 @@ class HeckAI(Provider):
                         streaming_text += content_chunk
                         yield dict(text=content_chunk) if not raw else content_chunk
                 
-                # Update history and previous answer after stream finishes
-                self.previous_answer = streaming_text
-                self.conversation.update_chat_history(prompt, streaming_text)
+                # Only update history if we received a valid response
+                if streaming_text:
+                    # Update history and previous answer after stream finishes
+                    self.previous_answer = streaming_text
+                    # Convert to simple text before updating conversation
+                    try:
+                        # Ensure content is valid before updating conversation
+                        if streaming_text and isinstance(streaming_text, str):
+                            # Sanitize the content to ensure it's valid
+                            sanitized_text = streaming_text.strip()
+                            if sanitized_text:  # Only update if we have non-empty content
+                                self.conversation.update_chat_history(prompt, sanitized_text)
+                    except Exception as e:
+                        # If conversation update fails, log but don't crash
+                        print(f"Warning: Failed to update conversation history: {str(e)}")
                     
             except CurlError as e: # Catch CurlError
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
@@ -177,7 +188,6 @@ class HeckAI(Provider):
                  if not full_text:
                      raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
 
-            # last_response and history are updated within for_stream
             # Return the final aggregated response dict or raw string
             self.last_response = {"text": full_text} # Update last_response here
             return full_text if raw else self.last_response
@@ -200,13 +210,13 @@ class HeckAI(Provider):
                 return text
         return text
 
-    def chat(
-        self,
-        prompt: str,
-        stream: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Union[str, Generator[str, None, None]]: # Corrected return type hint
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]: # Corrected return type hint
         def for_stream_chat():
             # ask() yields dicts or strings when streaming
             gen = self.ask(
@@ -226,32 +236,50 @@ class HeckAI(Provider):
             
         return for_stream_chat() if stream else for_non_stream_chat()
 
-    def get_message(self, response: dict) -> str:
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
-
-if __name__ == "__main__":
-    # Ensure curl_cffi is installed
-    print("-" * 80)
-    print(f"{'Model':<50} {'Status':<10} {'Response'}")
-    print("-" * 80)
+    def get_message(self, response: dict) -> str:
+        # Validate response format
+        if not isinstance(response, dict):
+            raise TypeError(f"Expected dict response, got {type(response).__name__}")
+        
+        # Handle missing text key gracefully
+        if "text" not in response:
+            return ""
+        
+        # Ensure text is a string
+        text = response["text"]
+        if not isinstance(text, str):
+            return str(text)
+            
+        return text
 
-    for model in HeckAI.AVAILABLE_MODELS:
-        try:
-            test_ai = HeckAI(model=model, timeout=60)
-            response = test_ai.chat("Say 'Hello' in one word", stream=True)
-            response_text = ""
-            for chunk in response:
-                response_text += chunk
-                print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
-            
-            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"\r{model:<50} {status:<10} {display_text}")
-        except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}")
+if __name__ == "__main__":
+    # Ensure curl_cffi is installed
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    for model in HeckAI.AVAILABLE_MODELS:
+        try:
+            test_ai = HeckAI(model=model, timeout=60)
+            # Use non-streaming mode first to avoid potential streaming issues
+            try:
+                response_text = test_ai.chat("Say 'Hello' in one word", stream=False)
+                print(f"\r{model:<50} {'✓':<10} {response_text.strip()[:50]}")
+            except Exception as e1:
+                # Fall back to streaming if non-streaming fails
+                print(f"\r{model:<50} {'Testing stream...':<10}", end="", flush=True)
+                response = test_ai.chat("Say 'Hello' in one word", stream=True)
+                response_text = ""
+                for chunk in response:
+                    if chunk and isinstance(chunk, str):
+                        response_text += chunk
+                
+                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()
+                    print(f"\r{model:<50} {status:<10} {display_text}")
+                else:
+                    raise ValueError("Empty or invalid response")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/Koboldai.py

@@ -125,6 +125,7 @@ class KOBOLDAI(Provider):
                 )
 
             message_load = ""
+            final_resp = None
             for value in response.iter_lines(
                 decode_unicode=True,
                 delimiter="" if raw else "event: message\ndata:",
@@ -135,12 +136,14 @@ class KOBOLDAI(Provider):
                     message_load += self.get_message(resp)
                     resp["token"] = message_load
                     self.last_response.update(resp)
-                    yield value if raw else resp
+                    final_resp = resp  # Always keep the latest
                 except json.decoder.JSONDecodeError:
                     pass
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+            if final_resp:
+                yield final_resp if not raw else json.dumps(final_resp)
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
 
         def for_non_stream():
             # let's make use of stream

webscout/Provider/LambdaChat.py

@@ -191,8 +191,8 @@ class LambdaChat(Provider):
         reasoning_text = ""
         if chunk["type"] == "stream" and "token" in chunk:
             return chunk["token"].replace("\u0000", "")
-        elif chunk["type"] == "finalAnswer":
-            return chunk.get("text")
+        # elif chunk["type"] == "finalAnswer":
+        #     return chunk.get("text")
         elif chunk["type"] == "reasoning" and chunk.get("subtype") == "stream" and "token" in chunk:
             # Prepend reasoning with <think> tags? Or handle separately? For now, just return token.
             return chunk["token"] # Or potentially format as f"<think>{chunk['token']}</think>"

webscout/Provider/Marcus.py

@@ -173,24 +173,16 @@ class Marcus(Provider):
         conversationally: bool = False,
     ) -> Union[str, Generator[str, None, None]]:
         """Generates a response from the AskMarcus API."""
-        def for_stream_chat():
-            # ask() yields dicts or strings when streaming
-            gen = self.ask(
-                prompt, stream=True, raw=False, # Ensure ask yields dicts
-                optimizer=optimizer, conversationally=conversationally
-            )
-            for response_dict in gen:
-                yield self.get_message(response_dict) # get_message expects dict
-
-        def for_non_stream_chat():
-            # ask() returns dict or str when not streaming
-            response_data = self.ask(
-                prompt, stream=False, raw=False, # Ensure ask returns dict
-                optimizer=optimizer, conversationally=conversationally
-            )
-            return self.get_message(response_data) # get_message expects dict
-
-        return for_stream_chat() if stream else for_non_stream_chat()
+        response_data = self.ask(
+            prompt, stream=False, raw=False, # Always get the full response
+            optimizer=optimizer, conversationally=conversationally
+        )
+        if stream:
+            def stream_wrapper():
+                yield self.get_message(response_data)
+            return stream_wrapper()
+        else:
+            return self.get_message(response_data)
 
     def get_message(self, response: Dict[str, Any]) -> str:
         """Extracts the message from the API response."""