webscout 8.3.4__py3-none-any.whl → 8.3.6__py3-none-any.whl

webscout/Provider/AISEARCH/stellar_search.py

@@ -53,7 +53,12 @@ class Stellar(AISearch):
 
     @staticmethod
     def _stellar_extractor(chunk: Union[str, bytes, Dict[str, Any]]) -> Optional[str]:
-        """Extracts content from the Stellar stream format with hex keys and diff arrays. Handles both str and bytes input."""
+        """
+        Extracts content from the Stellar stream format with focused pattern matching.
+        
+        Prioritizes the primary diff pattern to avoid duplication and focuses on
+        incremental content building from stellar.chatastra.ai streaming response.
+        """
         if isinstance(chunk, bytes):
             try:
                 chunk = chunk.decode('utf-8', errors='replace')
@@ -61,14 +66,54 @@ class Stellar(AISearch):
                 return None
         if not isinstance(chunk, str):
             return None
-        # Match patterns like 6e:{"diff":[0," empathy"],"next":"$@6f"}
-        pattern = r'[0-9a-f]+:\{"diff":\[0,"([^"\\]*)"\]'
-        matches = re.findall(pattern, chunk)
-        if matches:
-            extracted_text = ''.join(matches)
-            # Fix escaped newlines
-            extracted_text = extracted_text.replace('\\n', '\n').replace('\\n\\n', '\n\n')
+        
+        # Primary pattern: Hex key diff format (most reliable for streaming)
+        # Matches: 16:{"diff":[0,"AI"],"next":"$@18"}
+        primary_pattern = r'[0-9a-f]+:\{"diff":\[0,"([^"]*?)"\]'
+        primary_matches = re.findall(primary_pattern, chunk)
+        
+        if primary_matches:
+            # Join the matches and clean up
+            extracted_text = ''.join(primary_matches)
+            
+            # Handle escape sequences properly
+            extracted_text = extracted_text.replace('\\n', '\n')
+            extracted_text = extracted_text.replace('\\r', '\r')
+            extracted_text = extracted_text.replace('\\"', '"')
+            extracted_text = extracted_text.replace('\\t', '\t')
+            extracted_text = extracted_text.replace('\\/', '/')
+            extracted_text = extracted_text.replace('\\\\', '\\')
+            
+            # Clean up markdown formatting
+            extracted_text = extracted_text.replace('\\*', '*')
+            extracted_text = extracted_text.replace('\\#', '#')
+            extracted_text = extracted_text.replace('\\[', '[')
+            extracted_text = extracted_text.replace('\\]', ']')
+            extracted_text = extracted_text.replace('\\(', '(')
+            extracted_text = extracted_text.replace('\\)', ')')
+            
             return extracted_text if extracted_text.strip() else None
+        
+        # # Fallback: Look for Ta24 content blocks (complete responses)
+        # if ':Ta24,' in chunk:
+        #     ta24_pattern = r':Ta24,([^}]*?)(?:\d+:|$)'
+        #     ta24_matches = re.findall(ta24_pattern, chunk)
+        #     if ta24_matches:
+        #         extracted_text = ''.join(ta24_matches)
+        #         # Basic cleanup
+        #         extracted_text = extracted_text.replace('\\n', '\n')
+        #         extracted_text = extracted_text.replace('\\"', '"')
+        #         return extracted_text.strip() if extracted_text.strip() else None
+        
+        # # Secondary fallback: Direct diff patterns without hex prefix
+        # fallback_pattern = r'\{"diff":\[0,"([^"]*?)"\]'
+        # fallback_matches = re.findall(fallback_pattern, chunk)
+        # if fallback_matches:
+        #     extracted_text = ''.join(fallback_matches)
+        #     extracted_text = extracted_text.replace('\\n', '\n')
+        #     extracted_text = extracted_text.replace('\\"', '"')
+        #     return extracted_text if extracted_text.strip() else None
+        
         return None
 
     def search(self, prompt: str, stream: bool = False, raw: bool = False) -> Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse, str], None, None]]:

webscout/Provider/Deepinfra.py

@@ -18,8 +18,13 @@ class DeepInfra(Provider):
 
     AVAILABLE_MODELS = [
         "anthropic/claude-4-opus",
+        "moonshotai/Kimi-K2-Instruct",
         "anthropic/claude-4-sonnet",
         "deepseek-ai/DeepSeek-R1-0528-Turbo",
+        "Qwen/Qwen3-235B-A22B-Thinking-2507",
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo",
+        "Qwen/Qwen3-235B-A22B-Instruct-2507",
         "Qwen/Qwen3-235B-A22B",
         "Qwen/Qwen3-30B-A3B",
         "Qwen/Qwen3-32B",
@@ -71,12 +76,19 @@ class DeepInfra(Provider):
         "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
         "microsoft/WizardLM-2-8x22B",
         "mistralai/Devstral-Small-2505",
+        "mistralai/Devstral-Small-2507",
         "mistralai/Mistral-7B-Instruct-v0.3",
         "mistralai/Mistral-Nemo-Instruct-2407",
         "mistralai/Mistral-Small-24B-Instruct-2501",
         "mistralai/Mistral-Small-3.2-24B-Instruct-2506",
         "mistralai/Mixtral-8x7B-Instruct-v0.1",
         "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+        "zai-org/GLM-4.5-Air",
+        "zai-org/GLM-4.5",
+        "zai-org/GLM-4.5V",
+        "openai/gpt-oss-120b",
+        "openai/gpt-oss-20b",
+        "allenai/olmOCR-7B-0725-FP8",
     ]
 
     @staticmethod
@@ -339,7 +351,7 @@ if __name__ == "__main__":
 
     for model in DeepInfra.AVAILABLE_MODELS:
         try:
-            test_ai = DeepInfra(model=model, timeout=60, api_key="jwt:eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJnaDoxNTg5ODg0NzgiLCJleHAiOjE3NTI3NDI5NDV9.qM93p6bPZYi_ejaOo1Dbe4UjYXrFiM7XvBLN4-9BWag")
+            test_ai = DeepInfra(model=model, timeout=60,)
             response = test_ai.chat("Say 'Hello' in one word", stream=True)
             response_text = ""
             for chunk in response:

webscout/Provider/Flowith.py

@@ -15,7 +15,12 @@ class Flowith(Provider):
     """
     A provider class for interacting with the Flowith API.
     """
-    AVAILABLE_MODELS = ["gpt-4.1-nano", "gpt-4.1-mini", "deepseek-chat", "deepseek-reasoner", "claude-3.5-haiku", "gemini-2.0-flash", "gemini-2.5-flash", "grok-3-mini"]
+    # Updated list of supported models
+    AVAILABLE_MODELS = [
+        "gpt-5-nano", "gpt-5-mini", "glm-4.5", "gpt-oss-120b", "gpt-oss-20b", "kimi-k2",
+        "gpt-4.1", "gpt-4.1-mini", "deepseek-chat", "deepseek-reasoner",
+        "gemini-2.5-flash", "grok-3-mini"
+    ]
 
     def __init__(
         self,

webscout/Provider/GithubChat.py

@@ -20,6 +20,7 @@ class GithubChat(Provider):
     # Available models
     AVAILABLE_MODELS = [
         "gpt-4o",
+        "gpt-5",
         "o3-mini", 
         "o1", 
         "claude-3.5-sonnet",

webscout/Provider/GptOss.py

@@ -0,0 +1,207 @@
+
+import requests
+from typing import Any, Dict, Generator, Optional, Union, List
+from webscout.litagent import LitAgent
+from webscout.AIutel import sanitize_stream, Optimizers, Conversation, AwesomePrompts
+from webscout.AIbase import Provider
+from webscout import exceptions
+
+class GptOss(Provider):
+    """
+    Provider for GPT-OSS API.
+    """
+    AVAILABLE_MODELS = ["gpt-oss-20b", "gpt-oss-120b"]
+
+    def __init__(
+        self,
+        model: str = "gpt-oss-120b",
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        system_prompt: str = "You are a helpful assistant.",
+        reasoning_effort: str = "high"
+    ):
+        self.api_endpoint = "https://api.gpt-oss.com/chatkit"
+        self.model = model if model in self.AVAILABLE_MODELS else self.AVAILABLE_MODELS[0]
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.system_prompt = system_prompt
+        self.reasoning_effort = reasoning_effort
+        self.agent = LitAgent()
+        self.proxies = proxies
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        data = {
+            "op": "threads.create",
+            "params": {
+                "input": {
+                    "text": conversation_prompt,
+                    "content": [{"type": "input_text", "text": conversation_prompt}],
+                    "quoted_text": "",
+                    "attachments": []
+                }
+            }
+        }
+        headers = self.agent.generate_fingerprint()
+        headers.update({
+            "accept": "text/event-stream",
+            "x-reasoning-effort": self.reasoning_effort,
+            "x-selected-model": self.model,
+            "x-show-reasoning": "true"
+        })
+        cookies = {}
+
+        def for_stream():
+            full_response_content = ""
+            try:
+                with requests.post(
+                    self.api_endpoint,
+                    headers=headers,
+                    cookies=cookies,
+                    json=data,
+                    stream=True,
+                    proxies=self.proxies if self.proxies else None,
+                    timeout=self.timeout
+                ) as response:
+                    response.raise_for_status()
+                    for chunk in sanitize_stream(
+                        response.iter_lines(),
+                        intro_value="data: ",
+                        to_json=True,
+                        skip_markers=["[DONE]"],
+                        strip_chars=None,
+                        content_extractor=lambda d: d.get('update', {}).get('delta') if d.get('type') == 'thread.item_updated' and d.get('update', {}).get('type') == 'assistant_message.content_part.text_delta' else None,
+                        yield_raw_on_error=False,
+                        encoding="utf-8",
+                        raw=raw
+                    ):
+                        if chunk:
+                            yield chunk
+                            full_response_content += chunk
+                self.last_response.update(dict(text=full_response_content))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+
+        def for_non_stream():
+            result = ""
+            try:
+                with requests.post(
+                    self.api_endpoint,
+                    headers=headers,
+                    cookies=cookies,
+                    json=data,
+                    stream=False,
+                    proxies=self.proxies if self.proxies else None,
+                    timeout=self.timeout
+                ) as response:
+                    response.raise_for_status()
+                    # The API is event-stream only, so we simulate non-stream by joining all chunks
+                    for chunk in sanitize_stream(
+                        response.iter_lines(),
+                        intro_value="data: ",
+                        to_json=True,
+                        skip_markers=["[DONE]"],
+                        strip_chars=None,
+                        content_extractor=lambda d: d.get('update', {}).get('delta') if d.get('type') == 'thread.item_updated' and d.get('update', {}).get('type') == 'assistant_message.content_part.text_delta' else None,
+                        yield_raw_on_error=False,
+                        encoding="utf-8",
+                        raw=raw
+                    ):
+                        if chunk:
+                            result += chunk
+                self.last_response.update(dict(text=result))
+                self.conversation.update_chat_history(
+                    prompt, self.get_message(self.last_response)
+                )
+                return self.last_response
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        raw: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        def for_stream():
+            for response in self.ask(
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield response
+
+        def for_non_stream():
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+            )
+            return self.get_message(result)
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        text = response.get("text", "")
+        return text
+
+if __name__ == "__main__":
+    from webscout.AIutel import timeIt
+    from rich import print
+    ai = GptOss(timeout=30)
+    @timeIt
+    def get_response():
+        response = ai.chat("write a poem about AI", stream=True, raw=False)
+        for chunk in response:
+            print(chunk, end="", flush=True)
+    get_response()