webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/Provider/OPENAI/exaai.py

@@ -1,22 +1,30 @@
+import json
+import re
 import time
 import uuid
+from typing import Any, Dict, Generator, List, Optional, Union, cast
+
 import requests
-import json
-import re
-from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
-    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage
+from webscout.Provider.OPENAI.base import (
+    BaseChat,
+    BaseCompletions,
+    OpenAICompatibleProvider,
+    SimpleModelList,
+)
+from webscout.Provider.OPENAI.utils import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ChatCompletionMessage,
+    Choice,
+    ChoiceDelta,
+    CompletionUsage,
+    count_tokens,
 )
 
 # Attempt to import LitAgent, fallback if not available
-try:
-    from webscout.litagent import LitAgent
-except ImportError:
-    pass
+from ...litagent import LitAgent
 
 # --- ExaAI Client ---
 
@@ -25,8 +33,9 @@ BOLD = "\033[1m"
 RED = "\033[91m"
 RESET = "\033[0m"
 
+
 class Completions(BaseCompletions):
-    def __init__(self, client: 'ExaAI'):
+    def __init__(self, client: "ExaAI"):
         self._client = client
 
     def create(
@@ -38,7 +47,9 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
-        **kwargs: Any
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
         Creates a model response for the given chat conversation.
@@ -56,7 +67,9 @@ class Completions(BaseCompletions):
 
         if has_system_message:
             # Print warning in bold red
-            print(f"{BOLD}{RED}Warning: ExaAI does not support system messages, they will be ignored.{RESET}")
+            print(
+                f"{BOLD}{RED}Warning: ExaAI does not support system messages, they will be ignored.{RESET}"
+            )
 
         # If no messages left after filtering, raise an error
         if not filtered_messages:
@@ -66,10 +79,7 @@ class Completions(BaseCompletions):
         conversation_id = uuid.uuid4().hex[:16]
 
         # Prepare the payload for ExaAI API
-        payload = {
-            "id": conversation_id,
-            "messages": filtered_messages
-        }
+        payload = {"id": conversation_id, "messages": filtered_messages}
 
         # Add optional parameters if provided
         if max_tokens is not None and max_tokens > 0:
@@ -90,12 +100,20 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, payload)
+            return self._create_stream(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, payload)
+            return self._create_non_stream(
+                request_id, created_time, model, payload, timeout, proxies
+            )
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self,
+        request_id: str,
+        created_time: int,
+        model: str,
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             response = self._client.session.post(
@@ -103,7 +121,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None),
             )
 
             # Handle non-200 responses
@@ -119,73 +138,70 @@ class Completions(BaseCompletions):
 
             # Estimate prompt tokens based on message length
             for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
+                prompt_tokens += count_tokens(msg.get("content", ""))
+
+            finish_reason = None
+            usage = None
 
             for line in response.iter_lines(decode_unicode=True):
                 if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-
-                        # Format the content (replace escaped newlines)
-                        content = self._client.format_text(content)
-
-                        # Update token counts
-                        completion_tokens += 1
-                        total_tokens = prompt_tokens + completion_tokens
-
-                        # Create the delta object
-                        delta = ChoiceDelta(
-                            content=content,
-                            role="assistant",
-                            tool_calls=None
-                        )
-
-                        # Create the choice object
-                        choice = Choice(
-                            index=0,
-                            delta=delta,
-                            finish_reason=None,
-                            logprobs=None
-                        )
-
-                        # Create the chunk object
-                        chunk = ChatCompletionChunk(
-                            id=request_id,
-                            choices=[choice],
-                            created=created_time,
-                            model=model,
-                            system_fingerprint=None
-                        )
-
-                        # Convert to dict for proper formatting
-                        chunk_dict = chunk.to_dict()
-
-                        # Add usage information to match OpenAI format
-                        usage_dict = {
-                            "prompt_tokens": prompt_tokens,
-                            "completion_tokens": completion_tokens,
-                            "total_tokens": total_tokens,
-                            "estimated_cost": None
-                        }
-
-                        chunk_dict["usage"] = usage_dict
-
-                        # Return the chunk object for internal processing
-                        yield chunk
+                    if line.startswith("0:"):
+                        match = re.search(r'0:"(.*?)"', line)
+                        if match:
+                            content = match.group(1)
+
+                            # Format the content (replace escaped newlines)
+                            content = self._client.format_text(content)
+
+                            # Update token counts
+                            completion_tokens += count_tokens(content)
+                            total_tokens = prompt_tokens + completion_tokens
+
+                            # Create the delta object
+                            delta = ChoiceDelta(content=content, role="assistant", tool_calls=None)
+
+                            # Create the choice object
+                            choice = Choice(index=0, delta=delta, finish_reason=None, logprobs=None)
+
+                            # Create the chunk object
+                            chunk = ChatCompletionChunk(
+                                id=request_id,
+                                choices=[choice],
+                                created=created_time,
+                                model=model,
+                                system_fingerprint=None,
+                            )
+
+                            # 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
+                            usage_dict = {
+                                "prompt_tokens": prompt_tokens,
+                                "completion_tokens": completion_tokens,
+                                "total_tokens": total_tokens,
+                                "estimated_cost": None,
+                            }
+
+                            chunk_dict["usage"] = usage_dict
+
+                            # Return the chunk object for internal processing
+                            yield chunk
+                    elif line.startswith("e:") or line.startswith("d:"):
+                        data = json.loads(line[2:])
+                        if "finishReason" in data:
+                            finish_reason = data["finishReason"]
+                        if "usage" in data:
+                            usage = data["usage"]
 
             # Final chunk with finish_reason="stop"
-            delta = ChoiceDelta(
-                content=None,
-                role=None,
-                tool_calls=None
-            )
+            delta = ChoiceDelta(content=None, role=None, tool_calls=None)
 
             choice = Choice(
-                index=0,
-                delta=delta,
-                finish_reason="stop",
-                logprobs=None
+                index=0, delta=delta, finish_reason=finish_reason or "stop", logprobs=None
             )
 
             chunk = ChatCompletionChunk(
@@ -193,16 +209,22 @@ class Completions(BaseCompletions):
                 choices=[choice],
                 created=created_time,
                 model=model,
-                system_fingerprint=None
+                system_fingerprint=None,
             )
 
-            chunk_dict = chunk.to_dict()
-            chunk_dict["usage"] = {
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": total_tokens,
-                "estimated_cost": None
-            }
+            if hasattr(chunk, "model_dump"):
+                chunk_dict = chunk.model_dump(exclude_none=True)
+            else:
+                chunk_dict = chunk.dict(exclude_none=True)
+            if usage:
+                chunk_dict["usage"] = usage
+            else:
+                chunk_dict["usage"] = {
+                    "prompt_tokens": prompt_tokens,
+                    "completion_tokens": completion_tokens,
+                    "total_tokens": total_tokens,
+                    "estimated_cost": None,
+                }
 
             yield chunk
 
@@ -211,7 +233,13 @@ class Completions(BaseCompletions):
             raise IOError(f"ExaAI request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self,
+        request_id: str,
+        created_time: int,
+        model: str,
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
     ) -> ChatCompletion:
         try:
             # For non-streaming, we still use streaming internally to collect the full response
@@ -220,7 +248,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None),
             )
 
             # Handle non-200 responses
@@ -231,42 +260,50 @@ class Completions(BaseCompletions):
 
             # Collect the full response
             full_text = ""
+            usage = None
+            finish_reason = None
             for line in response.iter_lines(decode_unicode=True):
                 if line:
-                    match = re.search(r'0:"(.*?)"', line)
-                    if match:
-                        content = match.group(1)
-                        full_text += content
+                    if line.startswith("0:"):
+                        match = re.search(r'0:"(.*?)"', line)
+                        if match:
+                            content = match.group(1)
+                            full_text += content
+                    elif line.startswith("e:") or line.startswith("d:"):
+                        data = json.loads(line[2:])
+                        if "finishReason" in data:
+                            finish_reason = data["finishReason"]
+                        if "usage" in data:
+                            usage = data["usage"]
 
             # Format the text (replace escaped newlines)
             full_text = self._client.format_text(full_text)
 
-            # Estimate token counts
-            prompt_tokens = 0
-            for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
+            # Use actual usage if available, else estimate
+            if usage:
+                prompt_tokens = usage.get("promptTokens", 0)
+                completion_tokens = usage.get("completionTokens", 0)
+                total_tokens = usage.get("totalTokens", 0)
+            else:
+                # Estimate token counts
+                prompt_tokens = 0
+                for msg in payload.get("messages", []):
+                    prompt_tokens += count_tokens(msg.get("content", ""))
 
-            completion_tokens = len(full_text.split())
-            total_tokens = prompt_tokens + completion_tokens
+                completion_tokens = count_tokens(full_text)
+                total_tokens = prompt_tokens + completion_tokens
 
             # Create the message object
-            message = ChatCompletionMessage(
-                role="assistant",
-                content=full_text
-            )
+            message = ChatCompletionMessage(role="assistant", content=full_text)
 
             # Create the choice object
-            choice = Choice(
-                index=0,
-                message=message,
-                finish_reason="stop"
-            )
+            choice = Choice(index=0, message=message, finish_reason=finish_reason or "stop")
 
             # Create the usage object
-            usage = CompletionUsage(
+            usage_obj = CompletionUsage(
                 prompt_tokens=prompt_tokens,
                 completion_tokens=completion_tokens,
-                total_tokens=total_tokens
+                total_tokens=total_tokens,
             )
 
             # Create the completion object
@@ -275,7 +312,7 @@ class Completions(BaseCompletions):
                 choices=[choice],
                 created=created_time,
                 model=model,
-                usage=usage,
+                usage=usage_obj,
             )
 
             return completion
@@ -284,10 +321,12 @@ class Completions(BaseCompletions):
             print(f"Error during ExaAI non-stream request: {e}")
             raise IOError(f"ExaAI request failed: {e}") from e
 
+
 class Chat(BaseChat):
-    def __init__(self, client: 'ExaAI'):
+    def __init__(self, client: "ExaAI"):
         self.completions = Completions(client)
 
+
 class ExaAI(OpenAICompatibleProvider):
     """
     OpenAI-compatible client for ExaAI API.
@@ -303,47 +342,41 @@ class ExaAI(OpenAICompatibleProvider):
         ExaAI does not support system messages. Any system messages will be ignored.
     """
 
+    required_auth = False
     AVAILABLE_MODELS = ["O3-Mini"]
 
-    def __init__(
-        self,
-        timeout: Optional[int] = None,
-        browser: str = "chrome"
-    ):
+    def __init__(self, browser: str = "chrome"):
         """
         Initialize the ExaAI client.
 
         Args:
-            timeout: Request timeout in seconds (None for no timeout)
-            browser: Browser to emulate in user agent
+            browser: Browser to emulate in user agent (not used, hardcoded headers)
         """
-        self.timeout = timeout
+        self.timeout = 60  # Default timeout in seconds
+        self.proxies = None  # Default proxies
         self.api_endpoint = "https://o3minichat.exa.ai/api/chat"
         self.session = requests.Session()
 
-        # Initialize LitAgent for user agent generation
-        agent = LitAgent()
-        self.fingerprint = agent.generate_fingerprint(browser)
-
-        # Headers for the request
+        # Headers based on the curl command
         self.headers = {
             "authority": "o3minichat.exa.ai",
-            "accept": self.fingerprint["accept"],
-            "accept-encoding": "gzip, deflate, br, zstd",
-            "accept-language": self.fingerprint["accept_language"],
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
             "content-type": "application/json",
             "dnt": "1",
             "origin": "https://o3minichat.exa.ai",
             "priority": "u=1, i",
             "referer": "https://o3minichat.exa.ai/",
-            "sec-ch-ua": self.fingerprint["sec_ch_ua"] or '"Microsoft Edge";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
+            "sec-ch-ua": '"Microsoft Edge";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
             "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": f'"{self.fingerprint["platform"]}"',
+            "sec-ch-ua-platform": '"Windows"',
             "sec-fetch-dest": "empty",
             "sec-fetch-mode": "cors",
             "sec-fetch-site": "same-origin",
             "sec-gpc": "1",
-            "user-agent": self.fingerprint["user_agent"]
+            "user-agent": LitAgent().random()
+            if LitAgent
+            else "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
         }
 
         self.session.headers.update(self.headers)
@@ -364,12 +397,12 @@ class ExaAI(OpenAICompatibleProvider):
         # Use a more comprehensive approach to handle all escape sequences
         try:
             # First handle double backslashes to avoid issues
-            text = text.replace('\\\\', '\\')
+            text = text.replace("\\\\", "\\")
 
             # Handle common escape sequences
-            text = text.replace('\\n', '\n')
-            text = text.replace('\\r', '\r')
-            text = text.replace('\\t', '\t')
+            text = text.replace("\\n", "\n")
+            text = text.replace("\\r", "\r")
+            text = text.replace("\\t", "\t")
             text = text.replace('\\"', '"')
             text = text.replace("\\'", "'")
 
@@ -402,3 +435,18 @@ class ExaAI(OpenAICompatibleProvider):
         # ExaAI only supports O3-Mini, regardless of the input model
         print(f"Note: ExaAI only supports O3-Mini model. Ignoring provided model '{model}'.")
         return "O3-Mini"
+
+    @property
+    def models(self) -> SimpleModelList:
+        return SimpleModelList(type(self).AVAILABLE_MODELS)
+
+
+if __name__ == "__main__":
+    # Example usage
+    client = ExaAI()
+    response = client.chat.completions.create(
+        model="O3-Mini", messages=[{"role": "user", "content": "Hello, how are you?"}]
+    )
+    if isinstance(response, ChatCompletion):
+        if response.choices[0].message and response.choices[0].message.content:
+            print(response.choices[0].message.content)