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

webscout/Provider/OPENAI/heckai.py

@@ -34,6 +34,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,  # Not used by HeckAI but kept for compatibility
         top_p: Optional[float] = None,  # Not used by HeckAI but kept for compatibility
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any  # Not used by HeckAI but kept for compatibility
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -62,12 +64,12 @@ 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(
@@ -75,7 +77,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)
             )
             response.raise_for_status()
 
@@ -128,7 +131,7 @@ class Completions(BaseCompletions):
             raise IOError(f"HeckAI 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:
             answer_lines = []
@@ -138,7 +141,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)
             )
             response.raise_for_status()
             for line in response.iter_lines(decode_unicode=True):
@@ -210,14 +214,13 @@ class HeckAI(OpenAICompatibleProvider):
     """
 
     AVAILABLE_MODELS = [
-        "google/gemini-2.0-flash-001",
+        "google/gemini-2.5-flash-preview",
         "deepseek/deepseek-chat",
         "deepseek/deepseek-r1",
         "openai/gpt-4o-mini",
         "openai/gpt-4.1-mini",
         "x-ai/grok-3-mini-beta",
         "meta-llama/llama-4-scout"
-
     ]
 
     def __init__(

webscout/Provider/OPENAI/llmchatco.py

@@ -37,6 +37,8 @@ class Completions(BaseCompletions):
         top_p: Optional[float] = None, # Note: LLMChatCo doesn't seem to use top_p directly in payload
         web_search: bool = False, # LLMChatCo specific parameter
         system_prompt: Optional[str] = "You are a helpful assistant.", # Default system prompt if not provided
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -88,12 +90,12 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, actual_model, payload)
+            return self._create_stream(request_id, created_time, actual_model, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, actual_model, payload)
+            return self._create_non_stream(request_id, created_time, actual_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(
@@ -101,7 +103,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)
             )
 
             if not response.ok:
@@ -197,14 +200,14 @@ class Completions(BaseCompletions):
 
 
     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:
         # Non-streaming requires accumulating stream chunks
         full_response_content = ""
         finish_reason = "stop" # Assume stop unless error occurs
 
         try:
-            stream_generator = self._create_stream(request_id, created_time, model, payload)
+            stream_generator = self._create_stream(request_id, created_time, model, payload, timeout, proxies)
             for chunk in stream_generator:
                 if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content:
                     full_response_content += chunk.choices[0].delta.content
@@ -332,4 +335,3 @@ class LLMChatCo(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-

webscout/Provider/OPENAI/mcpcore.py

@@ -43,6 +43,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -75,12 +77,12 @@ 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_from_stream(request_id, created_time, model, payload)
+            return self._create_non_stream_from_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]:
         """Handles the streaming response from MCPCore."""
         final_usage_data = None # To store usage if received
@@ -90,7 +92,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),
                 impersonate="chrome110" # Impersonation often helps
             )
 
@@ -193,7 +196,7 @@ class Completions(BaseCompletions):
             raise IOError(f"MCPCore stream processing failed: {e}{error_details}") from e
 
     def _create_non_stream_from_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:
         """Handles the non-streaming response by making a single POST request (like deepinfra)."""
         try:
@@ -205,7 +208,8 @@ class Completions(BaseCompletions):
                 self._client.api_endpoint,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None),
                 impersonate="chrome110"
             )
             if not response.ok:
@@ -386,4 +390,3 @@ class MCPCore(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-

webscout/Provider/OPENAI/multichat.py

@@ -94,6 +94,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -132,7 +134,7 @@ class Completions(BaseCompletions):
             created_time = int(time.time())
 
             # Make the API request
-            response_text = self._client._make_api_request(user_message)
+            response_text = self._client._make_api_request(user_message, timeout=timeout, proxies=proxies)
 
             # If streaming is requested, simulate streaming with the full response
             if stream:

webscout/Provider/OPENAI/netwrck.py

@@ -37,6 +37,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -61,19 +63,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(
                 "https://netwrck.com/api/chatpred_or",
                 json=payload,
                 headers=self._client.headers,
-                timeout=self._client.timeout,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None),
                 stream=True
             )
             response.raise_for_status()
@@ -127,14 +130,15 @@ class Completions(BaseCompletions):
             raise IOError(f"Netwrck 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:
             response = self._client.session.post(
                 "https://netwrck.com/api/chatpred_or",
                 json=payload,
                 headers=self._client.headers,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
             

webscout/Provider/OPENAI/oivscode.py

@@ -29,6 +29,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -52,11 +54,11 @@ 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 _post_with_retry(self, payload, stream=False):
+    def _post_with_retry(self, payload, stream=False, timeout=None, proxies=None):
         """
         Try all endpoints until one succeeds or all fail.
         """
@@ -68,7 +70,8 @@ class Completions(BaseCompletions):
                     headers=self._client.headers,
                     json=payload,
                     stream=stream,
-                    timeout=self._client.timeout
+                    timeout=timeout or self._client.timeout,
+                    proxies=proxies or getattr(self._client, "proxies", None)
                 )
                 response.raise_for_status()
                 self._client.base_url = endpoint  # Update to working endpoint
@@ -79,10 +82,10 @@ class Completions(BaseCompletions):
         raise IOError(f"All oivscode endpoints failed: {last_exception}") from last_exception
 
     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._post_with_retry(payload, stream=True)
+            response = self._post_with_retry(payload, stream=True, timeout=timeout, proxies=proxies)
             prompt_tokens = 0
             completion_tokens = 0
             total_tokens = 0
@@ -160,10 +163,10 @@ class Completions(BaseCompletions):
             raise
 
     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:
-            response = self._post_with_retry(payload, stream=False)
+            response = self._post_with_retry(payload, stream=False, timeout=timeout, proxies=proxies)
             data = response.json()
 
             choices_data = data.get('choices', [])
@@ -284,4 +287,4 @@ if __name__ == "__main__":
         max_tokens=50,
         stream=False
     )
-    print(response)
+    print(response)

webscout/Provider/OPENAI/opkfc.py

@@ -30,6 +30,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -56,6 +58,8 @@ class Completions(BaseCompletions):
                 max_tokens=max_tokens,
                 temperature=temperature,
                 top_p=top_p,
+                timeout=timeout,
+                proxies=proxies,
                 **kwargs
             )
 
@@ -66,6 +70,8 @@ class Completions(BaseCompletions):
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
+            timeout=timeout,
+            proxies=proxies,
             **kwargs
         )
 
@@ -77,6 +83,8 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Implementation for streaming chat completions."""
@@ -144,7 +152,8 @@ class Completions(BaseCompletions):
                 headers=headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -254,6 +263,8 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> ChatCompletion:
         """Implementation for non-streaming chat completions."""
@@ -322,7 +333,8 @@ class Completions(BaseCompletions):
                 headers=headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -493,4 +505,3 @@ class OPKFC(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-

webscout/Provider/OPENAI/scirachat.py

@@ -45,6 +45,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -75,19 +77,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(
                 self._client.api_endpoint,
                 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
@@ -100,7 +103,8 @@ class Completions(BaseCompletions):
                         self._client.api_endpoint,
                         json=payload,
                         stream=True,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(
@@ -225,13 +229,14 @@ class Completions(BaseCompletions):
             raise IOError(f"SciraChat 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:
             response = self._client.session.post(
                 self._client.api_endpoint,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             
             # Handle non-200 responses
@@ -243,7 +248,8 @@ class Completions(BaseCompletions):
                     response = self._client.session.post(
                         self._client.api_endpoint,
                         json=payload,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(

webscout/Provider/OPENAI/sonus.py

@@ -35,6 +35,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,  # Not used by SonusAI but kept for compatibility
         top_p: Optional[float] = None,  # Not used by SonusAI but kept for compatibility
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any  # Not used by SonusAI but kept for compatibility
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -61,12 +63,12 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, files)
+            return self._create_stream(request_id, created_time, model, files, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, files)
+            return self._create_non_stream(request_id, created_time, model, files, timeout, proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, files: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, files: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             response = requests.post(
@@ -74,7 +76,8 @@ class Completions(BaseCompletions):
                 files=files,
                 headers=self._client.headers,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -131,14 +134,15 @@ class Completions(BaseCompletions):
             raise IOError(f"SonusAI request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, files: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, files: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         try:
             response = requests.post(
                 self._client.url,
                 files=files,
                 headers=self._client.headers,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 

webscout/Provider/OPENAI/standardinput.py

@@ -48,6 +48,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """Create a chat completion."""
@@ -85,16 +87,18 @@ class Completions(BaseCompletions):
 
         # Handle streaming vs non-streaming
         if stream:
-            return self._stream_request(request_id, created_time, model, payload)
+            return self._stream_request(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._non_stream_request(request_id, created_time, model, payload)
+            return self._non_stream_request(request_id, created_time, model, payload, timeout, proxies)
 
     def _non_stream_request(
         self,
         request_id: str,
         created_time: int,
         model: str,
-        payload: Dict[str, Any]
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Handle non-streaming request."""
         try:
@@ -103,7 +107,8 @@ class Completions(BaseCompletions):
                 self._client.api_endpoint,
                 cookies=self._client.cookies,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Check for errors
@@ -121,7 +126,8 @@ class Completions(BaseCompletions):
                         self._client.api_endpoint,
                         cookies=self._client.cookies,
                         json=payload,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(f"Failed to generate response after identity refresh - ({response.status_code}, {response.reason}) - {error_content}")
@@ -189,7 +195,9 @@ class Completions(BaseCompletions):
         request_id: str,
         created_time: int,
         model: str,
-        payload: Dict[str, Any]
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Handle streaming request."""
         try:
@@ -199,7 +207,8 @@ class Completions(BaseCompletions):
                 cookies=self._client.cookies,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Check for errors
@@ -218,7 +227,8 @@ class Completions(BaseCompletions):
                         cookies=self._client.cookies,
                         json=payload,
                         stream=True,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(f"Failed to generate response after identity refresh - ({response.status_code}, {response.reason}) - {error_content}")
@@ -430,4 +440,3 @@ class StandardInput(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-

webscout/Provider/OPENAI/textpollinations.py

@@ -34,6 +34,8 @@ class Completions(BaseCompletions):
         top_p: Optional[float] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -62,16 +64,18 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_streaming(request_id, created_time, model, payload)
+            return self._create_streaming(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._create_non_streaming(request_id, created_time, model, payload)
+            return self._create_non_streaming(request_id, created_time, model, payload, timeout, proxies)
 
     def _create_streaming(
         self,
         request_id: str,
         created_time: int,
         model: str,
-        payload: Dict[str, Any]
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Implementation for streaming chat completions."""
         try:
@@ -82,7 +86,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)
             )
 
             if not response.ok:
@@ -163,7 +168,9 @@ class Completions(BaseCompletions):
         request_id: str,
         created_time: int,
         model: str,
-        payload: Dict[str, Any]
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Implementation for non-streaming chat completions."""
         try:
@@ -173,7 +180,8 @@ class Completions(BaseCompletions):
                 self._client.api_endpoint,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             if not response.ok:
@@ -336,4 +344,3 @@ class TextPollinations(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-