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

webscout/Provider/TeachAnything.py

@@ -163,6 +163,7 @@ class TeachAnything(Provider):
         stream: bool = False, # Keep stream param for interface consistency
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Any]:
         """Generate response `str` or yield for streaming compatibility
         Args:
@@ -170,22 +171,29 @@ class TeachAnything(Provider):
             stream (bool, optional): Flag for streaming response. Defaults to False.
             optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
             conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            raw (bool, optional): If True, return raw string output.
         Returns:
             str or generator: Response generated
         """
         response_data = self.ask(
             prompt, 
             stream=False, # Call ask in non-stream mode internally
-            raw=False, # Ensure ask returns dict
+            raw=raw, # Pass raw flag
             optimizer=optimizer, 
             conversationally=conversationally
         )
         if stream:
             def stream_wrapper():
-                yield self.get_message(response_data)
+                if raw:
+                    yield response_data if isinstance(response_data, str) else self.get_message(response_data)
+                else:
+                    yield self.get_message(response_data)
             return stream_wrapper()
         else:
-            return self.get_message(response_data)
+            if raw:
+                return response_data if isinstance(response_data, str) else self.get_message(response_data)
+            else:
+                return self.get_message(response_data)
 
     def get_message(self, response: Union[dict, str]) -> str:
         """Retrieves message only from response

webscout/Provider/TextPollinationsAI.py

@@ -135,95 +135,98 @@ class TextPollinationsAI(Provider):
             payload["tool_choice"] = tool_choice
 
         def for_stream():
-            try: # Add try block for CurlError
-                # Use curl_cffi session post with impersonate
+            try:
                 response = self.session.post(
                     self.api_endpoint,
-                    # headers are set on the session
                     json=payload,
                     stream=True,
                     timeout=self.timeout,
-                    impersonate="chrome120" # Add impersonate
+                    impersonate="chrome120"
                 )
-
                 if not response.ok:
                     raise exceptions.FailedToGenerateResponseError(
                         f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                     )
-
                 streaming_text = ""
-                # Use sanitize_stream
                 processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    data=response.iter_content(chunk_size=None),
                     intro_value="data:",
-                    to_json=True,     # Stream sends JSON
+                    to_json=True,
                     skip_markers=["[DONE]"],
-                    # Extractor handles both content and tool_calls
                     content_extractor=lambda chunk: chunk.get('choices', [{}])[0].get('delta') if isinstance(chunk, dict) else None,
-                    yield_raw_on_error=False # Skip non-JSON or lines where extractor fails
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-
                 for delta in processed_stream:
-                    # delta is the extracted 'delta' object or None
-                    if delta and isinstance(delta, dict):
-                        if 'content' in delta and delta['content'] is not None:
-                            content = delta['content']
-                            streaming_text += content
-                            yield content if raw else dict(text=content)
-                        elif 'tool_calls' in delta:
-                            tool_calls = delta['tool_calls']
-                            yield tool_calls if raw else dict(tool_calls=tool_calls)
-
-                # Update history and last response after stream finishes
-                self.last_response.update(dict(text=streaming_text)) # Store aggregated text
-                if streaming_text: # Only update history if text was received
+                    if isinstance(delta, bytes):
+                        delta = delta.decode('utf-8', errors='ignore')
+                    if delta is None:
+                        continue
+                    if raw:
+                        # Only yield content or tool_calls as string
+                        if isinstance(delta, dict):
+                            if 'content' in delta and delta['content'] is not None:
+                                content = delta['content']
+                                streaming_text += content
+                                yield content
+                            elif 'tool_calls' in delta:
+                                tool_calls = delta['tool_calls']
+                                yield json.dumps(tool_calls)
+                        elif isinstance(delta, str):
+                            streaming_text += delta
+                            yield delta
+                    else:
+                        if isinstance(delta, dict):
+                            if 'content' in delta and delta['content'] is not None:
+                                content = delta['content']
+                                streaming_text += content
+                                yield dict(text=content)
+                            elif 'tool_calls' in delta:
+                                tool_calls = delta['tool_calls']
+                                yield dict(tool_calls=tool_calls)
+                self.last_response.update(dict(text=streaming_text))
+                if streaming_text:
                     self.conversation.update_chat_history(
-                        prompt, streaming_text # Use the fully aggregated text
+                        prompt, streaming_text
                     )
-            except CurlError as e: # Catch CurlError
+            except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
-            except Exception as e: # Catch other potential exceptions
+            except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}") from e
-
-
         def for_non_stream():
-            # Aggregate the stream using the updated for_stream logic
             final_content = ""
-            tool_calls_aggregated = None # To store potential tool calls
-            try: # Add try block for potential errors during aggregation
+            tool_calls_aggregated = None
+            try:
                 for chunk_data in for_stream():
-                    if isinstance(chunk_data, dict):
-                        if "text" in chunk_data:
-                            final_content += chunk_data["text"]
-                        elif "tool_calls" in chunk_data:
-                            # Aggregate tool calls (simple aggregation, might need refinement)
+                    if raw:
+                        if isinstance(chunk_data, str):
+                            final_content += chunk_data
+                        elif isinstance(chunk_data, bytes):
+                            final_content += chunk_data.decode('utf-8', errors='ignore')
+                        elif isinstance(chunk_data, list):
                             if tool_calls_aggregated is None:
                                 tool_calls_aggregated = []
-                            tool_calls_aggregated.extend(chunk_data["tool_calls"])
-                    elif isinstance(chunk_data, str): # Handle raw stream case
-                        final_content += chunk_data
-                    # Handle raw tool calls list if raw=True
-                    elif isinstance(chunk_data, list) and raw:
-                         if tool_calls_aggregated is None:
-                             tool_calls_aggregated = []
-                         tool_calls_aggregated.extend(chunk_data)
+                            tool_calls_aggregated.extend(chunk_data)
+                    else:
+                        if isinstance(chunk_data, dict):
+                            if "text" in chunk_data:
+                                final_content += chunk_data["text"]
+                            elif "tool_calls" in chunk_data:
+                                if tool_calls_aggregated is None:
+                                    tool_calls_aggregated = []
+                                tool_calls_aggregated.extend(chunk_data["tool_calls"])
+                        elif isinstance(chunk_data, str):
+                            final_content += chunk_data
             except Exception as e:
-                 # If aggregation fails but some text was received, use it. Otherwise, re-raise.
-                 if not final_content and not tool_calls_aggregated:
-                     raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
-
-
-            # last_response and history are updated within for_stream (for text)
-            # Return a dict containing text and/or tool_calls
+                if not final_content and not tool_calls_aggregated:
+                    raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
             result = {}
             if final_content:
                 result["text"] = final_content
             if tool_calls_aggregated:
                 result["tool_calls"] = tool_calls_aggregated
-            self.last_response = result # Update last_response with aggregated result
-            return self.last_response
-
-
+            self.last_response = result
+            return self.last_response if not raw else (final_content if final_content else json.dumps(tool_calls_aggregated) if tool_calls_aggregated else "")
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -234,27 +237,32 @@ class TextPollinationsAI(Provider):
         conversationally: bool = False,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Dict[str, Any]] = None,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Generator[str, None, None]]:
         """Generate response as a string"""
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally,
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally,
                 tools=tools, tool_choice=tool_choice
             ):
-                yield self.get_message(response)
-
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                    tools=tools,
-                    tool_choice=tool_choice,
-                )
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                tools=tools,
+                tool_choice=tool_choice,
             )
-
+            if raw:
+                return result if isinstance(result, str) else (result.get("text", "") if isinstance(result, dict) else str(result))
+            else:
+                return self.get_message(result)
         return for_stream() if stream else for_non_stream()
 
     def get_message(self, response: dict) -> str:

webscout/Provider/TogetherAI.py

@@ -15,21 +15,15 @@ class TogetherAI(Provider):
     """
 
     AVAILABLE_MODELS = [
-        "Gryphe/MythoMax-L2-13b",
-        "Gryphe/MythoMax-L2-13b-Lite",
         "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",
         "Qwen/Qwen2.5-7B-Instruct-Turbo",
-        "Qwen/Qwen2.5-Coder-32B-Instruct",
         "Qwen/Qwen2.5-VL-72B-Instruct",
-        "Qwen/Qwen3-235B-A22B-fp8",
         "Qwen/Qwen3-235B-A22B-fp8-tput",
-        "Rrrr/meta-llama/Llama-3-70b-chat-hf-6f9ad551",
-        "Rrrr/meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo-03dc18e1",
-        "Rrrr/meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo-6c92f39d",
+        "Salesforce/Llama-Rank-V1",
         "arcee-ai/arcee-blitz",
         "arcee-ai/caller",
         "arcee-ai/coder-large",
@@ -44,13 +38,12 @@ class TogetherAI(Provider):
         "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
         "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
         "deepseek-ai/DeepSeek-V3",
-        "deepseek-ai/DeepSeek-V3-p-dp",
         "google/gemma-2-27b-it",
-        "google/gemma-2b-it",
         "lgai/exaone-3-5-32b-instruct",
         "lgai/exaone-deep-32b",
         "marin-community/marin-8b-instruct",
-        "meta-llama/Llama-3-70b-chat-hf",
+        "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",
@@ -72,14 +65,8 @@ class TogetherAI(Provider):
         "mistralai/Mixtral-8x7B-Instruct-v0.1",
         "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
         "perplexity-ai/r1-1776",
-        "roberizk@gmail.com/meta-llama/Llama-3-70b-chat-hf-26ee936b",
-        "roberizk@gmail.com/meta-llama/Meta-Llama-3-70B-Instruct-6feb41f7",
-        "roberizk@gmail.com/meta-llama/Meta-Llama-3-8B-Instruct-8ced8839",
         "scb10x/scb10x-llama3-1-typhoon2-70b-instruct",
-        "scb10x/scb10x-llama3-1-typhoon2-8b-instruct",
-        "togethercomputer/MoA-1",
-        "togethercomputer/MoA-1-Turbo",
-        "togethercomputer/Refuel-Llm-V2",
+        "scb10x/scb10x-typhoon-2-1-gemma3-12b",
         "togethercomputer/Refuel-Llm-V2-Small",
     ]
 
@@ -220,14 +207,10 @@ class TogetherAI(Provider):
                 )
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
-
-        # Get API key if not already set
         if not self.headers.get("Authorization"):
             api_key = self.get_activation_key()
             self.headers["Authorization"] = f"Bearer {api_key}"
             self.session.headers.update(self.headers)
-
-        # Payload construction
         payload = {
             "model": self.model,
             "messages": [
@@ -236,7 +219,6 @@ class TogetherAI(Provider):
             ],
             "stream": stream
         }
-
         def for_stream():
             streaming_text = ""
             try:
@@ -248,23 +230,27 @@ class TogetherAI(Provider):
                     impersonate="chrome110"
                 )
                 response.raise_for_status()
-
-                # Use sanitize_stream
                 processed_stream = sanitize_stream(
                     data=response.iter_content(chunk_size=None),
                     intro_value="data:",
                     to_json=True,
                     skip_markers=["[DONE]"],
                     content_extractor=self._togetherai_extractor,
-                    yield_raw_on_error=False
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-
                 for content_chunk in processed_stream:
-                    if content_chunk and isinstance(content_chunk, str):
-                        streaming_text += content_chunk
-                        resp = dict(text=content_chunk)
-                        yield resp if not raw else content_chunk
-
+                    if isinstance(content_chunk, bytes):
+                        content_chunk = content_chunk.decode('utf-8', errors='ignore')
+                    if content_chunk is None:
+                        continue
+                    if raw:
+                        yield content_chunk
+                    else:
+                        if content_chunk and isinstance(content_chunk, str):
+                            streaming_text += content_chunk
+                            resp = dict(text=content_chunk)
+                            yield resp
             except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
             except Exception as e:
@@ -273,7 +259,6 @@ class TogetherAI(Provider):
                 if streaming_text:
                     self.last_response = {"text": streaming_text}
                     self.conversation.update_chat_history(prompt, streaming_text)
-
         def for_non_stream():
             try:
                 response = self.session.post(
@@ -283,30 +268,25 @@ class TogetherAI(Provider):
                     impersonate="chrome110"
                 )
                 response.raise_for_status()
-
                 response_text = response.text
-
-                # Use sanitize_stream to parse the non-streaming JSON response
                 processed_stream = sanitize_stream(
                     data=response_text,
                     to_json=True,
                     intro_value=None,
                     content_extractor=lambda chunk: chunk.get("choices", [{}])[0].get("message", {}).get("content") if isinstance(chunk, dict) else None,
-                    yield_raw_on_error=False
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-                content = next(processed_stream, None)
+                content = next((c for c in processed_stream if c is not None), None)
                 content = content if isinstance(content, str) else ""
-
                 self.last_response = {"text": content}
                 self.conversation.update_chat_history(prompt, content)
                 return self.last_response if not raw else content
-
             except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
             except Exception as e:
                 err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
                 raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {e} - {err_text}") from e
-
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -315,23 +295,27 @@ class TogetherAI(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Generator[str, None, None]]:
-        """Generate response `str`"""
         def for_stream_chat():
             gen = self.ask(
-                prompt, stream=True, raw=False,
+                prompt, stream=True, raw=raw,
                 optimizer=optimizer, conversationally=conversationally
             )
-            for response_dict in gen:
-                yield self.get_message(response_dict)
-
+            for response in gen:
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream_chat():
             response_data = self.ask(
-                prompt, stream=False, raw=False,
+                prompt, stream=False, raw=raw,
                 optimizer=optimizer, conversationally=conversationally
             )
-            return self.get_message(response_data)
-
+            if raw:
+                return response_data
+            else:
+                return self.get_message(response_data)
         return for_stream_chat() if stream else for_non_stream_chat()
 
     def get_message(self, response: dict) -> str:

webscout/Provider/Venice.py

@@ -20,7 +20,6 @@ class Venice(Provider):
     AVAILABLE_MODELS = [
         "mistral-31-24b",
         "dolphin-3.0-mistral-24b",
-        "llama-3.2-3b-akash",
         "qwen2dot5-coder-32b",
         "deepseek-coder-v2-lite",
 
@@ -128,83 +127,69 @@ class Venice(Provider):
                 )
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
-
-        # Update Payload construction based on successful request
         payload = {
-            "requestId": str(uuid4())[:7], # Keep generating request ID
+            "requestId": str(uuid4())[:7],
             "modelId": self.model,
             "prompt": [{"content": conversation_prompt, "role": "user"}],
-            "systemPrompt": self.system_prompt, # Use configured system prompt
+            "systemPrompt": self.system_prompt,
             "conversationType": "text",
-            "temperature": self.temperature, # Use configured temperature
-            "webEnabled": True, # Keep webEnabled
-            "topP": self.top_p, # Use configured topP
-            "includeVeniceSystemPrompt": True, # Set to True as per example
-            "isCharacter": False, # Keep as False
-            # Add missing fields from example payload
-            "userId": "user_anon_" + str(random.randint(1000000000, 9999999999)), # Generate anon user ID
-            "isDefault": True, 
+            "temperature": self.temperature,
+            "webEnabled": True,
+            "topP": self.top_p,
+            "includeVeniceSystemPrompt": True,
+            "isCharacter": False,
+            "userId": "user_anon_" + str(random.randint(1000000000, 9999999999)),
+            "isDefault": True,
             "textToSpeech": {"voiceId": "af_sky", "speed": 1},
-            "clientProcessingTime": random.randint(10, 50) # Randomize slightly
+            "clientProcessingTime": random.randint(10, 50)
         }
-
         def for_stream():
             try:
-                # Use curl_cffi session post
                 response = self.session.post(
                     self.api_endpoint, 
                     json=payload, 
                     stream=True, 
                     timeout=self.timeout,
-                    impersonate="edge101" # Match impersonation closer to headers
+                    impersonate="edge101"
                 ) 
-                # Check response status after the call
                 if response.status_code != 200:
-                    # Include response text in error
                     raise exceptions.FailedToGenerateResponseError(
                         f"Request failed with status code {response.status_code} - {response.text}"
                     )
-                    
                 streaming_text = ""
-                # 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_json=True,     # Each line is JSON
-                    content_extractor=self._venice_extractor, # Use the specific extractor
-                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                    data=response.iter_content(chunk_size=None),
+                    intro_value=None,
+                    to_json=True,
+                    content_extractor=self._venice_extractor,
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-
                 for content_chunk in processed_stream:
-                    # content_chunk is the string extracted by _venice_extractor
-                    if content_chunk and isinstance(content_chunk, str):
-                        streaming_text += content_chunk
-                        yield content_chunk if raw else dict(text=content_chunk)
-                
-                # Update history and last response after stream finishes
+                    # Always yield as string, even in raw mode
+                    if isinstance(content_chunk, bytes):
+                        content_chunk = content_chunk.decode('utf-8', errors='ignore')
+                    if raw:
+                        yield content_chunk
+                    else:
+                        if content_chunk and isinstance(content_chunk, str):
+                            streaming_text += content_chunk
+                            yield dict(text=content_chunk)
                 self.conversation.update_chat_history(prompt, streaming_text)
                 self.last_response = {"text": streaming_text} 
-                    
             except CurlError as e: 
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
-            # Catch requests.exceptions.RequestException if needed, but CurlError is primary for curl_cffi
             except Exception as e: 
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
-
         def for_non_stream():
             full_text = ""
-            # Iterate through the generator provided by for_stream
             for chunk_data in for_stream(): 
-                # Check if chunk_data is a dict (not raw) and has 'text'
                 if isinstance(chunk_data, dict) and "text" in chunk_data:
                     full_text += chunk_data["text"]
-                # If raw=True, chunk_data is the string content itself
                 elif isinstance(chunk_data, str): 
                      full_text += chunk_data
-            # Update last_response after aggregation
             self.last_response = {"text": full_text} 
             return self.last_response 
-
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -213,14 +198,20 @@ class Venice(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Generator]:
         def for_stream():
-            for response in self.ask(prompt, True, optimizer=optimizer, conversationally=conversationally):
-                yield self.get_message(response)
+            for response in self.ask(prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally):
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream():
-            return self.get_message(
-                self.ask(prompt, False, optimizer=optimizer, conversationally=conversationally)
-            )
+            result = self.ask(prompt, False, raw=raw, optimizer=optimizer, conversationally=conversationally)
+            if raw:
+                return result
+            else:
+                return self.get_message(result)
         return for_stream() if stream else for_non_stream()
 
     def get_message(self, response: dict) -> str: