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

webscout/Provider/OPENAI/exaai.py

@@ -38,6 +38,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]]:
         """
@@ -90,12 +92,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(
@@ -103,7 +105,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
@@ -217,7 +220,7 @@ 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
@@ -226,7 +229,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
@@ -313,17 +317,16 @@ class ExaAI(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: Optional[int] = None,
         browser: str = "chrome"
     ):
         """
         Initialize the ExaAI client.
 
         Args:
-            timeout: Request timeout in seconds (None for no timeout)
             browser: Browser to emulate in user agent
         """
-        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()
 
@@ -414,4 +417,4 @@ class ExaAI(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()

webscout/Provider/OPENAI/exachat.py

@@ -100,6 +100,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]]:
         """
@@ -136,12 +138,12 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, provider, payload)
+            return self._create_stream(request_id, created_time, model, provider, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, provider, payload)
+            return self._create_non_stream(request_id, created_time, model, provider, payload, timeout, proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, provider: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, provider: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             endpoint = self._client._get_endpoint(provider)
@@ -150,7 +152,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()
 
@@ -203,7 +206,7 @@ class Completions(BaseCompletions):
             raise IOError(f"ExaChat request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, provider: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, provider: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         try:
             endpoint = self._client._get_endpoint(provider)
@@ -211,7 +214,8 @@ class Completions(BaseCompletions):
                 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)
             )
             response.raise_for_status()
 

webscout/Provider/OPENAI/flowith.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]]:
         """
@@ -76,7 +78,8 @@ class Completions(BaseCompletions):
                     url,
                     json=payload,
                     stream=True,
-                    timeout=30
+                    timeout=timeout or 30,
+                    proxies=proxies
                 )
                 print(f"[DEBUG] Response status: {response.status_code}")
                 response.raise_for_status()
@@ -105,7 +108,8 @@ class Completions(BaseCompletions):
                 response = session.post(
                     url,
                     json=payload,
-                    timeout=30
+                    timeout=timeout or 30,
+                    proxies=proxies
                 )
                 print(f"[DEBUG] Response status: {response.status_code}")
                 response.raise_for_status()
@@ -159,4 +163,4 @@ class Flowith(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()

webscout/Provider/OPENAI/freeaichat.py

@@ -32,6 +32,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]]:
         """
@@ -55,12 +57,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(
@@ -68,7 +70,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
@@ -169,14 +172,15 @@ class Completions(BaseCompletions):
             raise IOError(f"FreeAIChat 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,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses

webscout/Provider/OPENAI/glider.py

@@ -44,6 +44,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]]:
         """
@@ -73,12 +75,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(
@@ -86,7 +88,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()
 
@@ -186,14 +189,15 @@ 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._client.session.post(
                 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)
             )
             response.raise_for_status()
             data = response.json()

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)