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

webscout/Provider/OPENAI/base.py

@@ -8,12 +8,11 @@ from webscout.Litlogger import Logger, LogLevel
 
 logger = Logger(name="OpenAIBase", level=LogLevel.INFO)
 
-# Import the ProxyAutoMeta metaclass
+# Import the LitMeta metaclass from Litproxy
 try:
-    from .autoproxy import ProxyAutoMeta
+    from litproxy import LitMeta 
 except ImportError:
-    # Fallback if autoproxy is not available
-    ProxyAutoMeta = type
+    from .autoproxy import ProxyAutoMeta as LitMeta
 
 
 # Import the utils for response structures
@@ -183,81 +182,11 @@ class BaseChat(ABC):
     completions: BaseCompletions
 
 
-# class ProxyAutoMeta(ABCMeta):
-#     """
-#     Metaclass to ensure all OpenAICompatibleProvider subclasses automatically get proxy support.
-#     This will inject proxies into any requests.Session, httpx.Client, or curl_cffi session attributes found on the instance.
-
-#     To disable automatic proxy injection, set disable_auto_proxy=True in the constructor or
-#     set the class attribute DISABLE_AUTO_PROXY = True.
-#     """
-#     def __call__(cls, *args, **kwargs):
-#         instance = super().__call__(*args, **kwargs)
-
-#         # Check if auto proxy is disabled
-#         disable_auto_proxy = kwargs.get('disable_auto_proxy', False) or getattr(cls, 'DISABLE_AUTO_PROXY', False)
-
-#         proxies = getattr(instance, 'proxies', None) or kwargs.get('proxies', None)
-#         if proxies is None and not disable_auto_proxy:
-#             try:
-#                 proxies = {"http": get_auto_proxy(), "https": get_auto_proxy()}
-#             except Exception as e:
-#                 logger.warning(f"Failed to get auto proxy, disabling proxy support: {e}")
-#                 proxies = {}
-#         elif proxies is None:
-#             proxies = {}
-#         instance.proxies = proxies
-#         # Patch sessions if we have valid proxies
-#         if proxies:
-#             for attr in dir(instance):
-#                 obj = getattr(instance, attr)
-#                 if isinstance(obj, requests.Session):
-#                     obj.proxies.update(proxies)
-#                 if httpx and isinstance(obj, httpx.Client):
-#                     try:
-#                         obj._proxies = proxies
-#                     except Exception:
-#                         pass
-#                 # Patch curl_cffi sessions if present
-#                 if CurlSession and isinstance(obj, CurlSession):
-#                     try:
-#                         obj.proxies.update(proxies)
-#                     except Exception:
-#                         pass
-#                 if CurlAsyncSession and isinstance(obj, CurlAsyncSession):
-#                     try:
-#                         obj.proxies.update(proxies)
-#                     except Exception:
-#                         pass
-#         # Provide helpers for proxied sessions
-#         def get_proxied_session():
-#             s = requests.Session()
-#             s.proxies.update(proxies)
-#             return s
-#         instance.get_proxied_session = get_proxied_session
-
-#         def get_proxied_curl_session(impersonate="chrome120", **kwargs):
-#             """Get a curl_cffi Session with proxies configured"""
-#             if CurlSession:
-#                 return CurlSession(proxies=proxies, impersonate=impersonate, **kwargs)
-#             else:
-#                 raise ImportError("curl_cffi is not installed")
-#         instance.get_proxied_curl_session = get_proxied_curl_session
-
-#         def get_proxied_curl_async_session(impersonate="chrome120", **kwargs):
-#             """Get a curl_cffi AsyncSession with proxies configured"""
-#             if CurlAsyncSession:
-#                 return CurlAsyncSession(proxies=proxies, impersonate=impersonate, **kwargs)
-#             else:
-#                 raise ImportError("curl_cffi is not installed")
-#         instance.get_proxied_curl_async_session = get_proxied_curl_async_session
-
-#         return instance
-class OpenAICompatibleProvider(ABC, metaclass=ProxyAutoMeta):
+class OpenAICompatibleProvider(ABC, metaclass=LitMeta):
     """
     Abstract Base Class for providers mimicking the OpenAI Python client structure.
     Requires a nested 'chat.completions' structure with tool support.
-    All subclasses automatically get proxy support via ProxyAutoMeta.
+    All subclasses automatically get proxy support via LitMeta.
 
     # Available proxy helpers:
     # - self.get_proxied_session() - returns a requests.Session with proxies
@@ -269,6 +198,8 @@ class OpenAICompatibleProvider(ABC, metaclass=ProxyAutoMeta):
     # - httpx.Client objects
     # - curl_cffi.requests.Session objects
     # - curl_cffi.requests.AsyncSession objects
+    #
+    # Inbuilt auto-retry is also enabled for all requests.Session and curl_cffi.Session objects.
     """
     chat: BaseChat
     available_tools: Dict[str, Tool] = {}  # Dictionary of available tools

webscout/Provider/OPENAI/copilot.py

@@ -86,14 +86,8 @@ class Completions(BaseCompletions):
                     raise RuntimeError(f"Image upload failed: {r.text}")
                 images.append({"type": "image", "url": r.json().get("url")})
 
-            # Connect to websocket
-            # Note: ws_connect might not use timeout in the same way as POST/GET
             ws = s.ws_connect(self._client.websocket_url)
-
-            # Use model to set mode ("reasoning" for Think Deeper)
             mode = "reasoning" if "Think" in model else "chat"
-
-            # Send the message to Copilot
             ws.send(json.dumps({
                 "event": "send",
                 "conversationId": conv_id,
@@ -101,79 +95,132 @@ class Completions(BaseCompletions):
                 "mode": mode
             }).encode(), CurlWsFlag.TEXT)
 
-            # Track token usage using count_tokens
             prompt_tokens = count_tokens(prompt_text)
             completion_tokens = 0
             total_tokens = prompt_tokens
-
             started = False
+            image_prompt = None
             while True:
                 try:
                     msg = json.loads(ws.recv()[0])
                 except Exception:
                     break
 
-                if msg.get("event") == "appendText":
+                event = msg.get("event")
+                if event not in ["appendText", "done", "error", "generatingImage", "imageGenerated", "suggestedFollowups", "replaceText"]:
+                    print(f"[Copilot] Unhandled event: {event} | msg: {msg}")
+
+                if event == "appendText":
                     started = True
                     content = msg.get("text", "")
-                    
-                    # Update token counts using count_tokens
                     content_tokens = count_tokens(content)
                     completion_tokens += content_tokens
                     total_tokens = prompt_tokens + completion_tokens
-
-                    # Create the delta object
                     delta = ChoiceDelta(
                         content=content,
                         role="assistant"
                     )
-
-                    # Create the choice object
                     choice = Choice(
                         index=0,
                         delta=delta,
                         finish_reason=None
                     )
-
-                    # Create the chunk object
                     chunk = ChatCompletionChunk(
                         id=request_id,
                         choices=[choice],
                         created=created_time,
                         model=model
                     )
-
                     yield chunk
-                elif msg.get("event") == "done":
-                    # Final chunk with finish_reason
+                elif event == "replaceText":
+                    # treat as appendText for OpenAI compatibility
+                    content = msg.get("text", "")
+                    content_tokens = count_tokens(content)
+                    completion_tokens += content_tokens
+                    total_tokens = prompt_tokens + completion_tokens
+                    delta = ChoiceDelta(
+                        content=content,
+                        role="assistant"
+                    )
+                    choice = Choice(
+                        index=0,
+                        delta=delta,
+                        finish_reason=None
+                    )
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model
+                    )
+                    yield chunk
+                elif event == "generatingImage":
+                    image_prompt = msg.get("prompt")
+                elif event == "imageGenerated":
+                    # Yield a chunk with image metadata in the delta (custom extension)
+                    delta = ChoiceDelta(
+                        content=None,
+                        role=None
+                    )
+                    choice = Choice(
+                        index=0,
+                        delta=delta,
+                        finish_reason=None
+                    )
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model
+                    )
+                    chunk.image_url = msg.get("url")
+                    chunk.image_prompt = image_prompt
+                    chunk.image_preview = msg.get("thumbnailUrl")
+                    yield chunk
+                elif event == "suggestedFollowups":
+                    # Yield a chunk with followups in the delta (custom extension)
+                    delta = ChoiceDelta(
+                        content=None,
+                        role=None
+                    )
+                    choice = Choice(
+                        index=0,
+                        delta=delta,
+                        finish_reason=None
+                    )
+                    chunk = ChatCompletionChunk(
+                        id=request_id,
+                        choices=[choice],
+                        created=created_time,
+                        model=model
+                    )
+                    chunk.suggested_followups = msg.get("suggestions")
+                    yield chunk
+                elif event == "done":
                     delta = ChoiceDelta(
                         content=None,
                         role=None
                     )
-
                     choice = Choice(
                         index=0,
                         delta=delta,
                         finish_reason="stop"
                     )
-
                     chunk = ChatCompletionChunk(
                         id=request_id,
                         choices=[choice],
                         created=created_time,
                         model=model
                     )
-
                     yield chunk
                     break
-                elif msg.get("event") == "error":
+                elif event == "error":
+                    print(f"[Copilot] Error event: {msg}")
                     raise RuntimeError(f"Copilot error: {msg}")
 
             ws.close()
-
             if not started:
                 raise RuntimeError("No response received from Copilot")
-
         except Exception as e:
             raise RuntimeError(f"Stream error: {e}") from e
         finally:

webscout/Provider/OPENAI/deepinfra.py

@@ -2,23 +2,20 @@ import requests
 import json
 import time
 import uuid
+import collections
 from typing import List, Dict, Optional, Union, Generator, Any
 
-# Import base classes and utility structures
 from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage
 )
 
-# Attempt to import LitAgent, fallback if not available
 try:
     from webscout.litagent import LitAgent
 except ImportError:
     pass
 
-# --- DeepInfra Client ---
-
 class Completions(BaseCompletions):
     def __init__(self, client: 'DeepInfra'):
         self._client = client
@@ -36,10 +33,6 @@ class Completions(BaseCompletions):
         proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        """
-        Creates a model response for the given chat conversation.
-        Mimics openai.chat.completions.create
-        """
         payload = {
             "model": model,
             "messages": messages,
@@ -50,12 +43,9 @@ class Completions(BaseCompletions):
             payload["temperature"] = temperature
         if top_p is not None:
             payload["top_p"] = top_p
-
         payload.update(kwargs)
-
         request_id = f"chatcmpl-{uuid.uuid4()}"
         created_time = int(time.time())
-
         if stream:
             return self._create_stream(request_id, created_time, model, payload, timeout, proxies)
         else:
@@ -75,52 +65,39 @@ class Completions(BaseCompletions):
                 proxies=proxies
             )
             response.raise_for_status()
-
-            # Track token usage across chunks
             prompt_tokens = 0
             completion_tokens = 0
             total_tokens = 0
-
-            for line in response.iter_lines():
+            for line in response.iter_lines(decode_unicode=True):
                 if line:
-                    decoded_line = line.decode('utf-8').strip()
-
-                    if decoded_line.startswith("data: "):
-                        json_str = decoded_line[6:]
+                    if line.startswith("data: "):
+                        json_str = line[6:]
                         if json_str == "[DONE]":
-                            # Format the final [DONE] marker in OpenAI format
-                            # print("data: [DONE]")
                             break
-
                         try:
                             data = json.loads(json_str)
                             choice_data = data.get('choices', [{}])[0]
                             delta_data = choice_data.get('delta', {})
                             finish_reason = choice_data.get('finish_reason')
-
-                            # Update token counts if available
                             usage_data = data.get('usage', {})
                             if usage_data:
                                 prompt_tokens = usage_data.get('prompt_tokens', prompt_tokens)
                                 completion_tokens = usage_data.get('completion_tokens', completion_tokens)
                                 total_tokens = usage_data.get('total_tokens', total_tokens)
-
-                            # Create the delta object
+                            if delta_data.get('content'):
+                                completion_tokens += 1
+                                total_tokens = prompt_tokens + completion_tokens
                             delta = ChoiceDelta(
                                 content=delta_data.get('content'),
                                 role=delta_data.get('role'),
                                 tool_calls=delta_data.get('tool_calls')
                             )
-
-                            # Create the choice object
                             choice = Choice(
                                 index=choice_data.get('index', 0),
                                 delta=delta,
                                 finish_reason=finish_reason,
                                 logprobs=choice_data.get('logprobs')
                             )
-
-                            # Create the chunk object
                             chunk = ChatCompletionChunk(
                                 id=request_id,
                                 choices=[choice],
@@ -128,48 +105,35 @@ class Completions(BaseCompletions):
                                 model=model,
                                 system_fingerprint=data.get('system_fingerprint')
                             )
-
-                            # Convert chunk to dict using Pydantic's API
-                            if hasattr(chunk, "model_dump"):
-                                chunk_dict = chunk.model_dump(exclude_none=True)
-                            else:
-                                chunk_dict = chunk.dict(exclude_none=True)
-
-                            # Add usage information to match OpenAI format
-                            # Even if we don't have real token counts, include estimated usage
-                            # This matches the format in the examples
-                            usage_dict = {
-                                "prompt_tokens": prompt_tokens or 10,
-                                "completion_tokens": completion_tokens or (len(delta_data.get('content', '')) if delta_data.get('content') else 0),
-                                "total_tokens": total_tokens or (10 + (len(delta_data.get('content', '')) if delta_data.get('content') else 0)),
+                            chunk.usage = {
+                                "prompt_tokens": prompt_tokens,
+                                "completion_tokens": completion_tokens,
+                                "total_tokens": total_tokens,
                                 "estimated_cost": None
                             }
-
-                            # Update completion_tokens and total_tokens as we receive more content
-                            if delta_data.get('content'):
-                                completion_tokens += 1
-                                total_tokens = prompt_tokens + completion_tokens
-                                usage_dict["completion_tokens"] = completion_tokens
-                                usage_dict["total_tokens"] = total_tokens
-
-                            chunk_dict["usage"] = usage_dict
-
-                            # Format the response in OpenAI format exactly as requested
-                            # We need to print the raw string and also yield the chunk object
-                            # This ensures both the console output and the returned object are correct
-                            # print(f"data: {json.dumps(chunk_dict)}")
-
-                            # Return the chunk object for internal processing
                             yield chunk
                         except json.JSONDecodeError:
-                            print(f"Warning: Could not decode JSON line: {json_str}")
                             continue
-        except requests.exceptions.RequestException as e:
+            # Final chunk with finish_reason="stop"
+            delta = ChoiceDelta(content=None, role=None, tool_calls=None)
+            choice = Choice(index=0, delta=delta, finish_reason="stop", logprobs=None)
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                system_fingerprint=None
+            )
+            chunk.usage = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "estimated_cost": None
+            }
+            yield chunk
+        except Exception as e:
             print(f"Error during DeepInfra stream request: {e}")
             raise IOError(f"DeepInfra request failed: {e}") from e
-        except Exception as e:
-            print(f"Error processing DeepInfra stream: {e}")
-            raise
 
     def _create_non_stream(
         self, request_id: str, created_time: int, model: str, payload: Dict[str, Any],
@@ -185,13 +149,19 @@ class Completions(BaseCompletions):
             )
             response.raise_for_status()
             data = response.json()
-
             choices_data = data.get('choices', [])
             usage_data = data.get('usage', {})
-
             choices = []
             for choice_d in choices_data:
-                message_d = choice_d.get('message', {})
+                message_d = choice_d.get('message')
+                if not message_d and 'delta' in choice_d:
+                    delta = choice_d['delta']
+                    message_d = {
+                        'role': delta.get('role', 'assistant'),
+                        'content': delta.get('content', '')
+                    }
+                if not message_d:
+                    message_d = {'role': 'assistant', 'content': ''}
                 message = ChatCompletionMessage(
                     role=message_d.get('role', 'assistant'),
                     content=message_d.get('content', '')
@@ -202,13 +172,11 @@ class Completions(BaseCompletions):
                     finish_reason=choice_d.get('finish_reason', 'stop')
                 )
                 choices.append(choice)
-
             usage = CompletionUsage(
                 prompt_tokens=usage_data.get('prompt_tokens', 0),
                 completion_tokens=usage_data.get('completion_tokens', 0),
                 total_tokens=usage_data.get('total_tokens', 0)
             )
-
             completion = ChatCompletion(
                 id=request_id,
                 choices=choices,
@@ -217,87 +185,83 @@ class Completions(BaseCompletions):
                 usage=usage,
             )
             return completion
-
-        except requests.exceptions.RequestException as e:
+        except Exception as e:
             print(f"Error during DeepInfra non-stream request: {e}")
             raise IOError(f"DeepInfra request failed: {e}") from e
-        except Exception as e:
-            print(f"Error processing DeepInfra response: {e}")
-            raise
 
 class Chat(BaseChat):
     def __init__(self, client: 'DeepInfra'):
         self.completions = Completions(client)
 
 class DeepInfra(OpenAICompatibleProvider):
-    
     AVAILABLE_MODELS = [
-        # "anthropic/claude-3-7-sonnet-latest",  # >>>> NOT WORKING
-        "deepseek-ai/DeepSeek-R1-0528",
-        "deepseek-ai/DeepSeek-R1",
-        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
-        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
-        "deepseek-ai/DeepSeek-R1-Turbo",
-        "deepseek-ai/DeepSeek-V3",
+        "anthropic/claude-4-opus",
+        "anthropic/claude-4-sonnet",
+        "deepseek-ai/DeepSeek-R1-0528-Turbo",
+        "Qwen/Qwen3-235B-A22B",
+        "Qwen/Qwen3-30B-A3B",
+        "Qwen/Qwen3-32B",
+        "Qwen/Qwen3-14B",
+        "deepseek-ai/DeepSeek-V3-0324-Turbo",
         "deepseek-ai/DeepSeek-Prover-V2-671B",
-        "google/gemma-2-27b-it",
-        "google/gemma-2-9b-it",
-        "google/gemma-3-12b-it",
+        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-Turbo",
+        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+        "deepseek-ai/DeepSeek-R1-0528",
+        "deepseek-ai/DeepSeek-V3-0324",
+        "mistralai/Mistral-Small-3.1-24B-Instruct-2503",
+        "microsoft/phi-4-reasoning-plus",
+        "Qwen/QwQ-32B",
+        "google/gemini-2.5-flash",
+        "google/gemini-2.5-pro",
         "google/gemma-3-27b-it",
+        "google/gemma-3-12b-it",
         "google/gemma-3-4b-it",
-        "meta-llama/Llama-3.3-70B-Instruct",
+        "microsoft/Phi-4-multimodal-instruct",
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "deepseek-ai/DeepSeek-V3",
         "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
-        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
-        "meta-llama/Llama-Guard-4-12B",
+        "meta-llama/Llama-3.3-70B-Instruct",
+        "microsoft/phi-4",
+        "Gryphe/MythoMax-L2-13b",
+        "NousResearch/Hermes-3-Llama-3.1-405B",
+        "NousResearch/Hermes-3-Llama-3.1-70B",
+        "NovaSky-AI/Sky-T1-32B-Preview",
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen/Qwen2.5-7B-Instruct",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Sao10K/L3-8B-Lunaris-v1-Turbo",
+        "Sao10K/L3.1-70B-Euryale-v2.2",
+        "Sao10K/L3.3-70B-Euryale-v2.3",
+        "anthropic/claude-3-7-sonnet-latest",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+        "deepseek-ai/DeepSeek-R1-Turbo",
+        "google/gemini-2.0-flash-001",
+        "meta-llama/Llama-3.2-11B-Vision-Instruct",
+        "meta-llama/Llama-3.2-1B-Instruct",
+        "meta-llama/Llama-3.2-3B-Instruct",
+        "meta-llama/Llama-3.2-90B-Vision-Instruct",
+        "meta-llama/Meta-Llama-3-70B-Instruct",
+        "meta-llama/Meta-Llama-3-8B-Instruct",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
         "meta-llama/Meta-Llama-3.1-8B-Instruct",
         "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
-        "microsoft/Phi-4-multimodal-instruct",
         "microsoft/WizardLM-2-8x22B",
-        "microsoft/phi-4",
-        "microsoft/phi-4-reasoning-plus",
+        "mistralai/Devstral-Small-2505",
+        "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",
-        "Qwen/QwQ-32B",
-        "Qwen/Qwen2.5-72B-Instruct",
-        "Qwen/Qwen2.5-Coder-32B-Instruct",
-        "Qwen/Qwen3-14B",
-        "Qwen/Qwen3-30B-A3B",
-        "Qwen/Qwen3-32B",
-        "Qwen/Qwen3-235B-A22B",
-        # "google/gemini-1.5-flash",  # >>>> NOT WORKING
-        # "google/gemini-1.5-flash-8b",  # >>>> NOT WORKING
-        # "google/gemini-2.0-flash-001",  # >>>> NOT WORKING
-
-        # "Gryphe/MythoMax-L2-13b",  # >>>> NOT WORKING
-
-        # "meta-llama/Llama-3.2-1B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Llama-3.2-3B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Llama-3.2-90B-Vision-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Llama-3.2-11B-Vision-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3-70B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3-8B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3.1-70B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3.1-405B-Instruct",  # >>>> NOT WORKING
-        # "mistralai/Mixtral-8x7B-Instruct-v0.1",  # >>>> NOT WORKING
-        # "mistralai/Mistral-7B-Instruct-v0.3",  # >>>> NOT WORKING
-        # "mistralai/Mistral-Nemo-Instruct-2407",  # >>>> NOT WORKING
-        # "NousResearch/Hermes-3-Llama-3.1-405B",  # >>>> NOT WORKING
-        # "NovaSky-AI/Sky-T1-32B-Preview",  # >>>> NOT WORKING
-        # "Qwen/Qwen2.5-7B-Instruct",  # >>>> NOT WORKING
-        # "Sao10K/L3.1-70B-Euryale-v2.2",  # >>>> NOT WORKING
-        # "Sao10K/L3.3-70B-Euryale-v2.3",  # >>>> NOT WORKING
     ]
-
-    def __init__(self, browser: str = "chrome"):
-        self.timeout = None # Default timeout
+    def __init__(self, browser: str = "chrome", api_key: str = None):
+        self.timeout = None
         self.base_url = "https://api.deepinfra.com/v1/openai/chat/completions"
         self.session = requests.Session()
-
         agent = LitAgent()
         fingerprint = agent.generate_fingerprint(browser)
-
         self.headers = {
             "Accept": fingerprint["accept"],
             "Accept-Encoding": "gzip, deflate, br, zstd",
@@ -317,23 +281,23 @@ class DeepInfra(OpenAICompatibleProvider):
             "Sec-CH-UA-Platform": f'"{fingerprint["platform"]}"',
             "User-Agent": fingerprint["user_agent"],
         }
+        if api_key is not None:
+            self.headers["Authorization"] = f"Bearer {api_key}"
         self.session.headers.update(self.headers)
         self.chat = Chat(self)
-
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-    
+
 if __name__ == "__main__":
-    # Example usage
     client = DeepInfra()
     response = client.chat.completions.create(
         model="deepseek-ai/DeepSeek-R1-0528",
         messages=[{"role": "user", "content": "Hello, how are you?"}],
-        max_tokens=100,
+        max_tokens=10000,
         stream=False
     )
     print(response)