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

webscout/Provider/scira_chat.py

@@ -17,19 +17,78 @@ class SciraAI(Provider):
     A class to interact with the Scira AI chat API.
     """
 
-    AVAILABLE_MODELS = {
-        "scira-default": "Grok3-mini", # thinking model
-        "scira-grok-3": "Grok3",
-        "scira-anthropic": "Claude 4 Sonnet",
-        "scira-anthropic-thinking": "Claude 4 Sonnet Thinking", # thinking model
-        "scira-vision" : "Grok2-Vision", # vision model
-        "scira-4o": "GPT4o",
-        "scira-qwq": "QWQ-32B",
-        "scira-o4-mini": "o4-mini",
-        "scira-google": "gemini 2.5 flash Thinking", # thinking model
-        "scira-google-pro": "gemini 2.5 pro",
-        "scira-llama-4": "llama 4 Maverick",
+    # Model mapping: actual model names to Scira API format
+    MODEL_MAPPING = {
+        "grok-3-mini": "scira-default",
+        "grok-3-mini-fast": "scira-x-fast-mini",
+        "grok-3-fast": "scira-x-fast",
+        "gpt-4.1-nano": "scira-nano",
+        "grok-3": "scira-grok-3",
+        "grok-4": "scira-grok-4",
+        "grok-2-vision-1212": "scira-vision",
+        "grok-2-latest": "scira-g2",
+        "gpt-4o-mini": "scira-4o-mini",
+        "o4-mini-2025-04-16": "scira-o4-mini",
+        "o3": "scira-o3",
+        "qwen/qwen3-32b": "scira-qwen-32b",
+        "qwen3-30b-a3b": "scira-qwen-30b",
+        "deepseek-v3-0324": "scira-deepseek-v3",
+        "claude-3-5-haiku-20241022": "scira-haiku",
+        "mistral-small-latest": "scira-mistral",
+        "gemini-2.5-flash-lite-preview-06-17": "scira-google-lite",
+        "gemini-2.5-flash": "scira-google",
+        "gemini-2.5-pro": "scira-google-pro",
+        "claude-sonnet-4-20250514": "scira-anthropic",
+        "claude-sonnet-4-20250514-thinking": "scira-anthropic-thinking",
+        "claude-4-opus-20250514": "scira-opus",
+        "claude-4-opus-20250514-pro": "scira-opus-pro",
+        "meta-llama/llama-4-maverick-17b-128e-instruct": "scira-llama-4",
+        "kimi-k2-instruct": "scira-kimi-k2",
+        "scira-kimi-k2": "kimi-k2-instruct",
     }
+    
+    # Reverse mapping: Scira format to actual model names
+    SCIRA_TO_MODEL = {v: k for k, v in MODEL_MAPPING.items()}
+    # Add special cases for aliases and duplicate mappings
+    SCIRA_TO_MODEL["scira-anthropic-thinking"] = "claude-sonnet-4-20250514"
+    SCIRA_TO_MODEL["scira-opus-pro"] = "claude-4-opus-20250514"
+    SCIRA_TO_MODEL["scira-x-fast"] = "grok-3-fast"
+    SCIRA_TO_MODEL["scira-x-fast-mini"] = "grok-3-mini-fast"
+    SCIRA_TO_MODEL["scira-nano"] = "gpt-4.1-nano"
+    SCIRA_TO_MODEL["scira-qwen-32b"] = "qwen/qwen3-32b"
+    SCIRA_TO_MODEL["scira-qwen-30b"] = "qwen3-30b-a3b"
+    SCIRA_TO_MODEL["scira-deepseek-v3"] = "deepseek-v3-0324"
+    SCIRA_TO_MODEL["scira-grok-4"] = "grok-4"
+    SCIRA_TO_MODEL["scira-kimi-k2"] = "kimi-k2-instruct"
+    SCIRA_TO_MODEL["kimi-k2-instruct"] = "scira-kimi-k2"
+    MODEL_MAPPING["claude-4-opus-20250514-pro"] = "scira-opus-pro"
+    # Available models list (actual model names + scira aliases)
+    AVAILABLE_MODELS = list(MODEL_MAPPING.keys()) + list(SCIRA_TO_MODEL.keys())
+    
+    @classmethod
+    def _resolve_model(cls, model: str) -> str:
+        """
+        Resolve a model name to its Scira API format.
+        
+        Args:
+            model: Either an actual model name or a Scira alias
+            
+        Returns:
+            The Scira API format model name
+            
+        Raises:
+            ValueError: If the model is not supported
+        """
+        # If it's already a Scira format, return as-is
+        if model in cls.SCIRA_TO_MODEL:
+            return model
+            
+        # If it's an actual model name, convert to Scira format
+        if model in cls.MODEL_MAPPING:
+            return cls.MODEL_MAPPING[model]
+            
+        # Model not found
+        raise ValueError(f"Invalid model: {model}. Choose from: {cls.AVAILABLE_MODELS}")
 
     def __init__(
         self,
@@ -42,7 +101,7 @@ class SciraAI(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        model: str = "scira-default",
+        model: str = "grok-3-mini",
         chat_id: str = None,
         user_id: str = None,
         browser: str = "chrome",
@@ -67,9 +126,9 @@ class SciraAI(Provider):
             system_prompt (str): System prompt for the AI.
 
         """
-        if model not in self.AVAILABLE_MODELS:
-            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
-
+        # Resolve the model to Scira format
+        self.model = self._resolve_model(model)
+        
         self.url = "https://scira.ai/api/search"
 
         # Initialize LitAgent for user agent generation
@@ -103,7 +162,6 @@ class SciraAI(Provider):
         self.max_tokens_to_sample = max_tokens
         self.timeout = timeout
         self.last_response = {}
-        self.model = model
         self.chat_id = chat_id or str(uuid.uuid4())
         self.user_id = user_id or f"user_{str(uuid.uuid4())[:8].upper()}"
 
@@ -357,7 +415,43 @@ class SciraAI(Provider):
         return response.get("text", "")
 
 if __name__ == "__main__":
-    ai = SciraAI()
-    resp = ai.chat("What is the capital of France?", stream=True, raw=False)
-    for chunk in resp:
-        print(chunk, end="", flush=True)
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+    
+    # Test all available models
+    working = 0
+    total = len(SciraAI.AVAILABLE_MODELS)
+    
+    for model in SciraAI.AVAILABLE_MODELS:
+        try:
+            test_ai = SciraAI(model=model, timeout=60)
+            # Test stream first
+            response_stream = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            print(f"\r{model:<50} {'Streaming...':<10}", end="", flush=True)
+            for chunk in response_stream:
+                response_text += chunk
+                # Optional: print chunks as they arrive for visual feedback
+                # print(chunk, end="", flush=True) 
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Clean and truncate response
+                clean_text = response_text.strip() # Already decoded in get_message
+                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
+            else:
+                status = "✗ (Stream)"
+                display_text = "Empty or invalid stream response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+            
+            # Optional: Add non-stream test if needed, but stream test covers basic functionality
+            # print(f"\r{model:<50} {'Non-Stream...':<10}", end="", flush=True)
+            # response_non_stream = test_ai.chat("Say 'Hi' again", stream=False)
+            # if not response_non_stream or len(response_non_stream.strip()) == 0:
+            #      print(f"\r{model:<50} {'✗ (Non-Stream)':<10} Empty non-stream response")
+
+
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")
+

webscout/Provider/toolbaz.py

@@ -37,8 +37,9 @@ class Toolbaz(Provider):
         "Qwen2.5-72B",
         "grok-2-1212",
         "grok-3-beta",
-        "toolbaz_v3.5_pro",
         "toolbaz_v3",
+        "toolbaz_v3.5_pro",
+        "toolbaz_v4",
         "mixtral_8x22b",
         "L3-70B-Euryale-v2.1",
         "midnight-rose",
@@ -112,12 +113,6 @@ class Toolbaz(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    @staticmethod
-    def _toolbaz_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Removes [model:...] tags from a string chunk."""
-        if isinstance(chunk, str):
-            return re.sub(r"\[model:.*?\]", "", chunk)
-        return None
 
     def random_string(self, length):
         return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
@@ -217,14 +212,14 @@ class Toolbaz(Provider):
 
                 streaming_text = ""
 
-                # Use sanitize_stream with the custom extractor
+                # Use sanitize_stream with skip_regexes to remove [model:...] tags
                 # It will decode bytes and yield processed string chunks
                 processed_stream = sanitize_stream(
                     data=resp.iter_content(chunk_size=None), # Pass byte iterator
                     intro_value=None, # No simple prefix
                     to_json=False,    # Content is text
-                    content_extractor=self._toolbaz_extractor, # Use the tag remover
-                    yield_raw_on_error=True, # Yield even if extractor somehow fails (though unlikely for regex)
+                    skip_regexes=[r"\[model:.*?\]"], # Skip [model:...] tags
+                    yield_raw_on_error=True, # Yield even if regex processing fails
                     raw=raw
                 )
 

webscout/Provider/typefully.py

@@ -71,16 +71,6 @@ class TypefullyAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    @staticmethod
-    def _typefully_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        if isinstance(chunk, str):
-            if isinstance(chunk, bytes):
-                chunk = chunk.decode('utf-8', errors='replace')
-            match = re.search(r'0:"(.*?)"', chunk)
-            if match:
-                content = match.group(1).encode().decode('unicode_escape')
-                return content.replace('\\', '\\').replace('\\"', '"')
-        return None
 
     def ask(
         self,
@@ -125,7 +115,7 @@ class TypefullyAI(Provider):
                     data=response.iter_content(chunk_size=None),
                     intro_value=None,
                     to_json=False,
-                    content_extractor=self._typefully_extractor,
+                    extract_regexes=[r'0:"(.*?)"'],
                     raw=raw
                 )
                 for content_chunk in processed_stream: