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

webscout/Provider/OPENAI/BLACKBOXAI.py

@@ -1,20 +1,198 @@
+# from pickle import NONE
+import requests
 import requests
 import random
 import string
 import base64
 from datetime import datetime, timedelta
-from typing import List, Dict, Optional, Any
-import json
+from typing import Generator, List, Dict, Optional, Any, Union
 import uuid
 import time
+import codecs
+import gzip
+import zstandard as zstd
+import brotli
+import zlib
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletion, Choice,
-    ChatCompletionMessage, CompletionUsage
+    ChatCompletionMessage, CompletionUsage, count_tokens,
+    ChatCompletionChunk # Added for streaming return type
 )
+from webscout.litagent import LitAgent
+agent = LitAgent()
 
+class StreamingDecompressor:
+    """
+    A streaming decompressor that can handle partial compressed data in real-time.
+    This allows for true streaming decompression without buffering entire response.
+    """
+    def __init__(self, content_encoding: str):
+        self.encoding = content_encoding.lower().strip() if content_encoding else None
+        self.decompressor = None
+        self.text_decoder = codecs.getincrementaldecoder("utf-8")("replace")
+        self.zstd_buffer = b""  # Buffer for zstd incomplete frames
+        
+        if self.encoding == 'gzip':
+            self.decompressor = zlib.decompressobj(16 + zlib.MAX_WBITS)  # gzip format
+        elif self.encoding == 'deflate':
+            self.decompressor = zlib.decompressobj()  # deflate format
+        elif self.encoding == 'zstd':
+            self.decompressor = zstd.ZstdDecompressor()
+        elif self.encoding == 'br':
+            self.decompressor = brotli.Decompressor()
+    
+    def decompress_chunk(self, chunk: bytes) -> str:
+        """
+        Decompress a chunk of data and return decoded text.
+        Handles partial compressed data properly for real-time streaming.
+        """
+        try:
+            if not chunk:
+                return ""
+            
+            if not self.encoding or self.encoding not in ['gzip', 'deflate', 'zstd', 'br']:
+                # No compression or unsupported - decode directly
+                return self.text_decoder.decode(chunk, final=False)
+            
+            if self.encoding in ['gzip', 'deflate']:
+                # Use zlib decompressor for gzip/deflate
+                decompressed_data = self.decompressor.decompress(chunk)
+                return self.text_decoder.decode(decompressed_data, final=False)
+            
+            elif self.encoding == 'zstd':
+                # Zstandard streaming decompression with buffering for incomplete frames
+                self.zstd_buffer += chunk
+                try:
+                    # Try to decompress the current buffer
+                    decompressed_data = self.decompressor.decompress(self.zstd_buffer)
+                    # If successful, clear the buffer and return decoded text
+                    self.zstd_buffer = b""
+                    return self.text_decoder.decode(decompressed_data, final=False)
+                except zstd.ZstdError:
+                    # Frame is incomplete, keep buffering
+                    # Try to decompress any complete frames from buffer start
+                    try:
+                        # Process buffer in chunks to find complete frames
+                        buffer_len = len(self.zstd_buffer)
+                        if buffer_len > 4:  # Minimum zstd frame size
+                            # Try smaller chunks of the buffer
+                            for end_pos in range(4, buffer_len + 1):
+                                try:
+                                    partial_data = self.decompressor.decompress(self.zstd_buffer[:end_pos])
+                                    # If we got here, we found a complete frame
+                                    self.zstd_buffer = self.zstd_buffer[end_pos:]
+                                    return self.text_decoder.decode(partial_data, final=False)
+                                except zstd.ZstdError:
+                                    continue
+                    except Exception:
+                        pass
+                    return ""
+            
+            elif self.encoding == 'br':
+                # Brotli streaming decompression
+                try:
+                    decompressed_data = self.decompressor.decompress(chunk)
+                    return self.text_decoder.decode(decompressed_data, final=False)
+                except brotli.error:
+                    # If brotli fails, it might need more data or be at end
+                    return ""
+        
+        except Exception as e:
+            # If decompression fails, try to decode the chunk as-is (fallback)
+            try:
+                return self.text_decoder.decode(chunk, final=False)
+            except UnicodeDecodeError:
+                return ""
+    
+    def finalize(self) -> str:
+        """
+        Finalize the decompression and return any remaining decoded text.
+        """
+        try:
+            remaining_text = ""
+            
+            if self.encoding in ['gzip', 'deflate'] and self.decompressor:
+                # Flush any remaining compressed data
+                remaining_data = self.decompressor.flush()
+                if remaining_data:
+                    remaining_text = self.text_decoder.decode(remaining_data, final=True)
+                else:
+                    remaining_text = self.text_decoder.decode(b"", final=True)
+            elif self.encoding == 'zstd':
+                # Process any remaining buffered data
+                if self.zstd_buffer:
+                    try:
+                        remaining_data = self.decompressor.decompress(self.zstd_buffer)
+                        remaining_text = self.text_decoder.decode(remaining_data, final=True)
+                    except:
+                        # If buffered data can't be decompressed, finalize decoder
+                        remaining_text = self.text_decoder.decode(b"", final=True)
+                else:
+                    remaining_text = self.text_decoder.decode(b"", final=True)
+            else:
+                # Finalize the text decoder for other encodings
+                remaining_text = self.text_decoder.decode(b"", final=True)
+            
+            return remaining_text
+        except Exception:
+            # Ensure we always finalize the text decoder
+            try:
+                return self.text_decoder.decode(b"", final=True)
+            except:
+                return ""
+
+def decompress_response(response_content: bytes, content_encoding: str) -> str:
+    """
+    Decompress response content based on the Content-Encoding header.
+    
+    Args:
+        response_content: The raw response content as bytes
+        content_encoding: The Content-Encoding header value
+        
+    Returns:
+        str: The decompressed and decoded content as UTF-8 string
+        
+    Raises:
+        IOError: If decompression fails
+    """
+    try:
+        if not content_encoding:
+            # No compression, decode directly
+            return response_content.decode('utf-8')
+        
+        encoding = content_encoding.lower().strip()
+        
+        if encoding == 'zstd':
+            # Decompress using zstandard
+            dctx = zstd.ZstdDecompressor()
+            decompressed_data = dctx.decompress(response_content)
+            return decompressed_data.decode('utf-8')
+        
+        elif encoding == 'gzip':
+            # Decompress using gzip
+            decompressed_data = gzip.decompress(response_content)
+            return decompressed_data.decode('utf-8')
+        
+        elif encoding == 'br':
+            # Decompress using brotli
+            decompressed_data = brotli.decompress(response_content)
+            return decompressed_data.decode('utf-8')
+        
+        elif encoding == 'deflate':
+            # Decompress using zlib (deflate)
+            import zlib
+            decompressed_data = zlib.decompress(response_content)
+            return decompressed_data.decode('utf-8')
+        
+        else:
+            # Unknown or unsupported encoding, try to decode as-is
+            return response_content.decode('utf-8')
+            
+    except Exception as e:
+        raise IOError(f"Failed to decompress response with encoding '{content_encoding}': {str(e)}") from e
 
 def to_data_uri(image_data):
     """Convert image data to a data URI format"""
@@ -36,6 +214,19 @@ def to_data_uri(image_data):
 
     return f"data:{mime_type};base64,{encoded}"
 
+def clean_text(text):
+    """Clean text by removing null bytes and control characters except newlines and tabs."""
+    import re
+    if not isinstance(text, str):
+        return text
+    
+    # Remove null bytes
+    text = text.replace('\x00', '')
+    
+    # Keep newlines, tabs, and other printable characters, remove other control chars
+    # This regex matches control characters except \n, \r, \t
+    return re.sub(r'[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
+
 
 class Completions(BaseCompletions):
     def __init__(self, client: 'BLACKBOXAI'):
@@ -50,8 +241,10 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
-    ) -> ChatCompletion:
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
         Create a chat completion with BlackboxAI API.
 
@@ -59,18 +252,14 @@ class Completions(BaseCompletions):
             model: The model to use (from AVAILABLE_MODELS)
             messages: List of message dictionaries with 'role' and 'content'
             max_tokens: Maximum number of tokens to generate
-            stream: If True, raises an error as streaming is not supported
+            stream: If True, yields streaming chunks
             temperature: Sampling temperature (0-1)
             top_p: Nucleus sampling parameter (0-1)
             **kwargs: Additional parameters to pass to the API
 
         Returns:
-            Returns a ChatCompletion object
+            Returns a ChatCompletion object or a generator for streaming
         """
-        # Check if streaming is requested and raise an error
-        if stream:
-            raise ValueError("Streaming is not supported by the BLACKBOXAI provider. Please use stream=False.")
-
         # Generate request ID and timestamp
         request_id = str(uuid.uuid4())
         created_time = int(time.time())
@@ -108,6 +297,22 @@ class Completions(BaseCompletions):
                                     except Exception as e:
                                         pass
 
+        # Check if streaming is requested and raise an error
+        if stream:
+            return self._create_streaming(
+                request_id=request_id,
+                created_time=created_time,
+                model=model,
+                messages=messages,
+                system_message=system_message,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                media=media,
+                timeout=timeout,
+                proxies=proxies
+            )
+
         # Use non-streaming implementation
         return self._create_non_streaming(
             request_id=request_id,
@@ -118,11 +323,12 @@ class Completions(BaseCompletions):
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
-            media=media
+            media=media,
+            timeout=timeout,
+            proxies=proxies
         )
 
 
-
     def _create_non_streaming(
         self,
         *,
@@ -134,9 +340,14 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
-        media: List = None
+        media: List = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None
     ) -> ChatCompletion:
         """Implementation for non-streaming chat completions."""
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
         try:
             # Prepare user messages for BlackboxAI API format
             blackbox_messages = []
@@ -157,7 +368,7 @@ class Completions(BaseCompletions):
                     "imagesData": [
                         {
                             "filePath": f"/",
-                            "contents": to_data_uri(image)
+                            "contents": to_data_uri(image[0])
                         } for image in media
                     ],
                     "fileText": "",
@@ -186,14 +397,23 @@ class Completions(BaseCompletions):
                 json=payload,
                 headers=self._client.headers,
                 cookies=self._client.cookies,
-                timeout=self._client.timeout
+                timeout=timeout if timeout is not None else self._client.timeout
             )
 
             # Process the response
             full_content = ""
             if response.status_code == 200:
-                # Extract content from response text
-                response_text = response.text
+                # Check for Content-Encoding header
+                content_encoding = response.headers.get('Content-Encoding')
+                
+                # Decompress the response if needed
+                try:
+                    response_text = decompress_response(response.content, content_encoding)
+                except IOError as e:
+                    # If decompression fails, fall back to the original method
+                    print(f"Warning: {e}. Falling back to original decoding method.")
+                    decoder = codecs.getincrementaldecoder("utf-8")("replace")
+                    response_text = decoder.decode(response.content, final=True)
 
                 # Handle possible SSE format in response
                 if "data: " in response_text:
@@ -216,10 +436,11 @@ class Completions(BaseCompletions):
                 # Handle error response
                 raise IOError(f"BlackboxAI request failed with status code {response.status_code}")
 
-            # Create the completion message
+            # Clean and create the completion message
+            cleaned_content = clean_text(full_content)
             message = ChatCompletionMessage(
                 role="assistant",
-                content=full_content
+                content=cleaned_content
             )
 
             # Create the choice with the message
@@ -229,9 +450,9 @@ class Completions(BaseCompletions):
                 finish_reason="stop"
             )
 
-            # Estimate token usage
-            prompt_tokens = sum(len(str(msg.get("content", ""))) // 4 for msg in messages)
-            completion_tokens = len(full_content) // 4
+            # Estimate token usage using count_tokens
+            prompt_tokens = count_tokens([str(msg.get("content", "")) for msg in messages])
+            completion_tokens = count_tokens(cleaned_content)
 
             # Create the final completion object
             completion = ChatCompletion(
@@ -250,6 +471,148 @@ class Completions(BaseCompletions):
 
         except Exception as e:
             raise IOError(f"BlackboxAI request failed: {str(e)}") from e
+        finally:
+            if proxies is not None:
+                self._client.session.proxies = original_proxies
+
+    def _create_streaming(
+        self,
+        *,
+        request_id: str,
+        created_time: int,
+        model: str,
+        messages: List[Dict[str, Any]],
+        system_message: str,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        media: List = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None
+    ):
+        """Implementation for streaming chat completions (OpenAI-compatible chunks)."""
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        try:
+            # Prepare user messages for BlackboxAI API format
+            blackbox_messages = []
+            for i, msg in enumerate(messages):
+                if msg["role"] == "system":
+                    continue  # System message handled separately
+                msg_id = self._client.generate_id() if i > 0 else request_id
+                blackbox_messages.append({
+                    "id": msg_id,
+                    "content": msg["content"],
+                    "role": msg["role"]
+                })
+            # Add image data if provided
+            if media and blackbox_messages:
+                blackbox_messages[-1]['data'] = {
+                    "imagesData": [
+                        {
+                            "filePath": f"/",
+                            "contents": to_data_uri(image[0])
+                        } for image in media
+                    ],
+                    "fileText": "",
+                    "title": ""
+                }
+            # Generate request payload with session
+            request_email = f"{self._client.generate_random_string(8)}@blackbox.ai"
+            session_data = self._client.generate_session(request_email)
+            payload = self._client.create_request_payload(
+                messages=blackbox_messages,
+                chat_id=request_id,
+                system_message=system_message,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                session_data=session_data,
+                model=model
+            )
+            # Make the API request with cookies, stream=True
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                json=payload,
+                headers=self._client.headers,
+                cookies=self._client.cookies,
+                stream=True,
+                timeout=timeout if timeout is not None else self._client.timeout
+            )
+            # Blackbox streams as raw text, no line breaks, so chunk manually
+            import codecs
+            chunk_size = 32  # Tune as needed for smoothness
+            from webscout.Provider.OPENAI.utils import ChatCompletionChunk, Choice, ChoiceDelta
+            
+            # Check if the response is compressed and create appropriate decompressor
+            content_encoding = response.headers.get('Content-Encoding')
+            streaming_decompressor = StreamingDecompressor(content_encoding)
+            
+            # Stream with real-time decompression
+            for chunk in response.iter_content(chunk_size=chunk_size):
+                if not chunk:
+                    continue
+                
+                # Decompress chunk in real-time
+                text = streaming_decompressor.decompress_chunk(chunk)
+                
+                if text:
+                    cleaned_chunk = clean_text(text)
+                    if cleaned_chunk.strip():
+                        delta = ChoiceDelta(content=cleaned_chunk, role="assistant")
+                        choice = Choice(index=0, delta=delta, finish_reason=None)
+                        chunk_obj = ChatCompletionChunk(
+                            id=request_id,
+                            choices=[choice],
+                            created=created_time,
+                            model=model,
+                            system_fingerprint=None
+                        )
+                        yield chunk_obj
+            
+            # Finalize decompression and get any remaining text
+            final_text = streaming_decompressor.finalize()
+            if final_text.strip():
+                cleaned_final = clean_text(final_text)
+                delta = ChoiceDelta(content=cleaned_final, role="assistant")
+                choice = Choice(index=0, delta=delta, finish_reason=None)
+                chunk_obj = ChatCompletionChunk(
+                    id=request_id,
+                    choices=[choice],
+                    created=created_time,
+                    model=model,
+                    system_fingerprint=None
+                )
+                yield chunk_obj
+            
+            # Send final chunk with finish_reason="stop"
+            delta = ChoiceDelta(content="", role="assistant")
+            choice = Choice(index=0, delta=delta, finish_reason="stop")
+            final_chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                system_fingerprint=None
+            )
+            yield final_chunk
+            
+        except Exception as e:
+            # Handle errors gracefully by yielding an error chunk
+            error_delta = ChoiceDelta(content=f"Error: {str(e)}", role="assistant")
+            error_choice = Choice(index=0, delta=error_delta, finish_reason="stop")
+            error_chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[error_choice],
+                created=created_time,
+                model=model,
+                system_fingerprint=None
+            )
+            yield error_chunk
+        finally:
+            if proxies is not None:
+                self._client.session.proxies = original_proxies
 
 
 class Chat(BaseChat):
@@ -273,7 +636,7 @@ class BLACKBOXAI(OpenAICompatibleProvider):
     default_model = "GPT-4.1"
     default_vision_model = default_model
     api_endpoint = "https://www.blackbox.ai/api/chat"
-    timeout = 30
+    timeout = None
 
 
     # Default model (remains the same as per original class)
@@ -329,11 +692,17 @@ class BLACKBOXAI(OpenAICompatibleProvider):
 
     # New base models list
     models = [
+        "gpt-4.1-mini", # Added new model
         default_model,
         "o3-mini",
         "gpt-4.1-nano",
+        "Claude Opus 4",  # Added Claude Opus 4
+        "Claude Sonnet 4",  # Added Claude Sonnet 4
         "Claude-sonnet-3.7",
         "Claude-sonnet-3.5",
+        "Grok 3",  # Added Grok 3
+        "Gemini 2.5 Pro",  # Added Gemini 2.5 Pro
+        "UI-TARS 72B",  # Added UI-TARS 72B
         "DeepSeek-R1",
         "Mistral-Small-24B-Instruct-2501",
         *openrouter_models,
@@ -347,10 +716,10 @@ class BLACKBOXAI(OpenAICompatibleProvider):
     ]
 
     # Models that support vision capabilities
-    vision_models = [default_vision_model, 'o3-mini', "Llama 3.2 11B Vision Instruct"] # Added Llama vision
+    vision_models = [default_vision_model, 'o3-mini', "Llama 3.2 11B Vision Instruct", "Gemini 2.5 Pro", "Claude Sonnet 4", "Claude Opus 4", "UI-TARS 72B"] # Added Llama vision, Gemini 2.5 Pro, Claude Sonnet 4, Claude Opus 4, and UI-TARS 72B
 
     # Models that can be directly selected by users
-    userSelectedModel = ['o3-mini','Claude-sonnet-3.7', 'Claude-sonnet-3.5', 'DeepSeek-R1', 'Mistral-Small-24B-Instruct-2501'] + openrouter_models
+    userSelectedModel = ['o3-mini', 'Claude Opus 4', 'Claude Sonnet 4', 'Claude-sonnet-3.7', 'Claude-sonnet-3.5', 'Grok 3', 'Gemini 2.5 Pro', 'UI-TARS 72B', 'DeepSeek-R1', 'Mistral-Small-24B-Instruct-2501'] + openrouter_models
 
     # Agent mode configurations
     agentMode = {
@@ -399,14 +768,20 @@ class BLACKBOXAI(OpenAICompatibleProvider):
         'R1 Distill Qwen 14B': {'mode': True, 'id': "deepseek/deepseek-r1-distill-qwen-14b:free", 'name': "R1 Distill Qwen 14B"},
         'R1 Distill Qwen 32B': {'mode': True, 'id': "deepseek/deepseek-r1-distill-qwen-32b:free", 'name': "R1 Distill Qwen 32B"},
         # Default models from the new list
+        'Claude Opus 4': {'mode': True, 'id': "anthropic/claude-opus-4", 'name': "Claude Opus 4"},
+        'Claude Sonnet 4': {'mode': True, 'id': "anthropic/claude-sonnet-4", 'name': "Claude Sonnet 4"},
         'Claude-sonnet-3.7': {'mode': True, 'id': "Claude-sonnet-3.7", 'name': "Claude-sonnet-3.7"},
         'Claude-sonnet-3.5': {'mode': True, 'id': "Claude-sonnet-3.5", 'name': "Claude-sonnet-3.5"},
+        'Grok 3': {'mode': True, 'id': "x-ai/grok-3-beta", 'name': "Grok 3"},
+        'Gemini 2.5 Pro': {'mode': True, 'id': "google/gemini-2.5-pro-preview-03-25", 'name': "Gemini 2.5 Pro"},
+        'UI-TARS 72B': {'mode': True, 'id': "bytedance-research/ui-tars-72b:free", 'name': "UI-TARS 72B"},
         'DeepSeek-R1': {'mode': True, 'id': "deepseek-reasoner", 'name': "DeepSeek-R1"}, # This is 'R1' in openrouter, but 'DeepSeek-R1' in base models
         'Mistral-Small-24B-Instruct-2501': {'mode': True, 'id': "mistralai/Mistral-Small-24B-Instruct-2501", 'name': "Mistral-Small-24B-Instruct-2501"},
         # Add default_model if it's not covered and has an agent mode
         default_model: {'mode': True, 'id': "openai/gpt-4.1", 'name': default_model}, # Assuming GPT-4.1 is agent-compatible
         'o3-mini': {'mode': True, 'id': "o3-mini", 'name': "o3-mini"}, # Assuming o3-mini is agent-compatible
         'gpt-4.1-nano': {'mode': True, 'id': "gpt-4.1-nano", 'name': "gpt-4.1-nano"}, # Assuming gpt-4.1-nano is agent-compatible
+        'gpt-4.1-mini': {'mode': True, 'id': "gpt-4.1-mini", 'name': "gpt-4.1-mini"}, # Added agent mode for gpt-4.1-mini
     }
 
     # Trending agent modes
@@ -442,101 +817,19 @@ class BLACKBOXAI(OpenAICompatibleProvider):
         'Heroku Agent': {'mode': True, 'id': "heroku"},
     }
 
-    # Create a list of all model aliases
-    _all_model_aliases = list(dict.fromkeys([
-        # Add all model aliases
-        "gpt-4", "gpt-4.1", "gpt-4o", "gpt-4o-mini",
-        "claude-3.7-sonnet", "claude-3.5-sonnet",
-        "deepcoder-14b", "deephermes-3-8b", "deepseek-r1-zero", "deepseek-r1",
-        "dolphin-3.0-24b", "dolphin-3.0-r1-24b", "reka-flash", "gemini-2.0-flash",
-        "gemma-2-9b", "gemma-3-12b", "gemma-3-1b", "gemma-3-27b", "gemma-3-4b",
-        "kimi-vl-a3b-thinking", "llama-3.1-8b", "nemotron-253b", "llama-3.2-11b",
-        "llama-3.2-1b", "llama-3.2-3b", "llama-3.3-70b", "nemotron-49b",
-        "llama-4-maverick", "llama-4-scout", "mistral-7b", "mistral-nemo",
-        "mistral-small-24b", "mistral-small-24b-instruct-2501", "mistral-small-3.1-24b",
-        "molmo-7b", "moonlight-16b", "qwen-2.5-72b", "qwen-2.5-7b", "qwen-2.5-coder-32b",
-        "qwen-2.5-vl-32b", "qwen-2.5-vl-3b", "qwen-2.5-vl-72b", "qwen-2.5-vl-7b",
-        "qwerky-72b", "qwq-32b", "qwq-32b-preview", "qwq-32b-arliai",
-        "deepseek-r1-distill-llama-70b", "deepseek-r1-distill-qwen-14b", "deepseek-r1-distill-qwen-32b",
-        # Add base models
-        "o3-mini", "gpt-4.1-nano"
-    ]))
-
-    # Create AVAILABLE_MODELS as a list with the format "BLACKBOXAI/model"
-    AVAILABLE_MODELS = [f"BLACKBOXAI/{name}" for name in _all_model_aliases]
-
-    # Create a mapping dictionary for internal use
-    _model_mapping = {name: f"BLACKBOXAI/{name}" for name in _all_model_aliases}
-
-
-    # Model aliases for easier reference
-    model_aliases = {
-        "gpt-4": default_model, # default_model is "GPT-4.1"
-        "gpt-4.1": default_model,
-        "gpt-4o": default_model, # Defaulting to GPT-4.1 as per previous logic if specific GPT-4o handling isn't defined elsewhere
-        "gpt-4o-mini": default_model, # Defaulting
-        "claude-3.7-sonnet": "Claude-sonnet-3.7",
-        "claude-3.5-sonnet": "Claude-sonnet-3.5",
-        # "deepseek-r1": "DeepSeek-R1", # This is in base models, maps to R1 or DeepSeek R1 Zero in agentMode
-        #
-        "deepcoder-14b": "Deepcoder 14B Preview",
-        "deephermes-3-8b": "DeepHermes 3 Llama 3 8B Preview",
-        "deepseek-r1-zero": "DeepSeek R1 Zero",
-        "deepseek-r1": "R1", # Alias for R1 (which is deepseek/deepseek-r1:free)
-        "dolphin-3.0-24b": "Dolphin3.0 Mistral 24B",
-        "dolphin-3.0-r1-24b": "Dolphin3.0 R1 Mistral 24B",
-        "reka-flash": "Flash 3",
-        "gemini-2.0-flash": "Gemini 2.0 Flash Experimental",
-        "gemma-2-9b": "Gemma 2 9B",
-        "gemma-3-12b": "Gemma 3 12B",
-        "gemma-3-1b": "Gemma 3 1B",
-        "gemma-3-27b": "Gemma 3 27B",
-        "gemma-3-4b": "Gemma 3 4B",
-        "kimi-vl-a3b-thinking": "Kimi VL A3B Thinking",
-        "llama-3.1-8b": "Llama 3.1 8B Instruct",
-        "nemotron-253b": "Llama 3.1 Nemotron Ultra 253B v1",
-        "llama-3.2-11b": "Llama 3.2 11B Vision Instruct",
-        "llama-3.2-1b": "Llama 3.2 1B Instruct",
-        "llama-3.2-3b": "Llama 3.2 3B Instruct",
-        "llama-3.3-70b": "Llama 3.3 70B Instruct",
-        "nemotron-49b": "Llama 3.3 Nemotron Super 49B v1",
-        "llama-4-maverick": "Llama 4 Maverick",
-        "llama-4-scout": "Llama 4 Scout",
-        "mistral-7b": "Mistral 7B Instruct",
-        "mistral-nemo": "Mistral Nemo",
-        "mistral-small-24b": "Mistral Small 3", # Alias for "Mistral Small 3"
-        "mistral-small-24b-instruct-2501": "Mistral-Small-24B-Instruct-2501", # Specific name
-        "mistral-small-3.1-24b": "Mistral Small 3.1 24B",
-        "molmo-7b": "Molmo 7B D",
-        "moonlight-16b": "Moonlight 16B A3B Instruct",
-        "qwen-2.5-72b": "Qwen2.5 72B Instruct",
-        "qwen-2.5-7b": "Qwen2.5 7B Instruct",
-        "qwen-2.5-coder-32b": "Qwen2.5 Coder 32B Instruct",
-        "qwen-2.5-vl-32b": "Qwen2.5 VL 32B Instruct",
-        "qwen-2.5-vl-3b": "Qwen2.5 VL 3B Instruct",
-        "qwen-2.5-vl-72b": "Qwen2.5 VL 72B Instruct",
-        "qwen-2.5-vl-7b": "Qwen2.5-VL 7B Instruct",
-        "qwerky-72b": "Qwerky 72B",
-        "qwq-32b": "QwQ 32B",
-        "qwq-32b-preview": "QwQ 32B Preview",
-        "qwq-32b-arliai": "QwQ 32B RpR v1",
-        "deepseek-r1-distill-llama-70b": "R1 Distill Llama 70B",
-        "deepseek-r1-distill-qwen-14b": "R1 Distill Qwen 14B",
-        "deepseek-r1-distill-qwen-32b": "R1 Distill Qwen 32B",
-    }
+    # Create AVAILABLE_MODELS as a list with just the model aliases (no "BLACKBOXAI/" prefix)
+    AVAILABLE_MODELS = list(models)
+
 
     def __init__(
-        self,
-        proxies: dict = {}
+        self
     ):
         """
         Initialize the BlackboxAI provider with OpenAI compatibility.
-
-        Args:
-            proxies: Optional proxy configuration
         """
         # Initialize session
         self.session = requests.Session()
+        self.session.proxies = {}
 
         # Set headers based on GitHub reference
         self.headers = {
@@ -553,7 +846,7 @@ class BLACKBOXAI(OpenAICompatibleProvider):
             'Sec-Fetch-Dest': 'empty',
             'Sec-Fetch-Mode': 'cors',
             'Sec-Fetch-Site': 'same-origin',
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36'
+            'User-Agent': agent.random(),
         }
 
         # Set cookies for the session
@@ -563,9 +856,6 @@ class BLACKBOXAI(OpenAICompatibleProvider):
             '__cf_bm': self.generate_id(32),
         }
 
-        # Set proxies if provided
-        self.session.proxies = proxies
-
         # Initialize chat interface with completions
         self.chat = Chat(self)
 
@@ -579,29 +869,11 @@ class BLACKBOXAI(OpenAICompatibleProvider):
 
     @classmethod
     def get_model(cls, model: str) -> str:
-        """Resolve model name from alias."""
-        # Remove BLACKBOXAI/ prefix if present
+        """Return the model name, removing BLACKBOXAI/ prefix if present, or default_model."""
         if model.startswith("BLACKBOXAI/"):
             model = model[len("BLACKBOXAI/"):]
-
-        # Convert to lowercase for case-insensitive matching
-        model_lower = model.lower()
-
-        # Check aliases (case-insensitive)
-        for alias, target in cls.model_aliases.items():
-            if model_lower == alias.lower():
-                return target
-
-        # If the model is directly in available models (without the prefix), return it
-        for available_model in cls._all_model_aliases:
-            if model_lower == available_model.lower():
-                # Find the corresponding model in model_aliases or use the model directly
-                for alias, target in cls.model_aliases.items():
-                    if available_model.lower() == alias.lower():
-                        return target
-                return available_model
-
-        # If we get here, use the default model
+        if model in cls.AVAILABLE_MODELS:
+            return model
         return cls.default_model
 
     @classmethod
@@ -733,3 +1005,13 @@ class BLACKBOXAI(OpenAICompatibleProvider):
             "designerMode": False,
             "workspaceId": ""
         }
+if __name__ == "__main__":
+    # Example usage
+    client = BLACKBOXAI()
+    response = client.chat.completions.create(
+        model="GPT-4.1",
+        messages=[{"role": "user", "content": "Tell me about india in points"}],
+        stream=True
+    )
+    for chunk in response:
+        print(chunk.choices[0].delta.content, end='', flush=True)