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

webscout/Provider/OPENAI/opkfc.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 import time
 import uuid
 import requests
@@ -6,12 +7,12 @@ import random
 from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage, count_tokens
 )
-
+from webscout.litagent import LitAgent
 # ANSI escape codes for formatting
 BOLD = "\033[1m"
 RED = "\033[91m"
@@ -30,6 +31,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 +59,8 @@ class Completions(BaseCompletions):
                 max_tokens=max_tokens,
                 temperature=temperature,
                 top_p=top_p,
+                timeout=timeout,
+                proxies=proxies,
                 **kwargs
             )
 
@@ -66,6 +71,8 @@ class Completions(BaseCompletions):
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
+            timeout=timeout,
+            proxies=proxies,
             **kwargs
         )
 
@@ -77,6 +84,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 +153,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 +264,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 +334,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()
 
@@ -454,7 +467,9 @@ class OPKFC(OpenAICompatibleProvider):
         "auto",
         "o4-mini",
         "gpt-4o-mini",
-        "gpt-4o"
+        "gpt-4o",
+        "gpt-4-1-mini",
+        
     ]
 
     def __init__(
@@ -479,10 +494,10 @@ class OPKFC(OpenAICompatibleProvider):
             self.session.proxies.update(proxies)
 
         # Set the user agent to match the original script
-        self.user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0"
+        self.user_agent = LitAgent().random()
 
         # Set the cookie from the original script
-        self.cookie = "__vtins__KUc0LhjVWFNXQv11=%7B%22sid%22%3A%20%228fab09e3-c23e-5f60-b369-9697fbb821ce%22%2C%20%22vd%22%3A%201%2C%20%22stt%22%3A%200%2C%20%22dr%22%3A%200%2C%20%22expires%22%3A%201744896723481%2C%20%22ct%22%3A%201744894923481%7D; __51uvsct__KUc0LhjVWFNXQv11=1; __51vcke__KUc0LhjVWFNXQv11=06da852c-bb56-547c-91a8-43a0d485ffed; __51vuft__KUc0LhjVWFNXQv11=1744894923504; gfsessionid=1ochrgv17vy4sbd98xmwt6crpmkxwlqf; oai-nav-state=1; p_uv_id=ad86646801bc60d6d95f6098e4ee7450; _dd_s=rum=0&expire=1744895920821&logs=1&id=a39221c9-e8ed-44e6-a2c8-03192699c71e&created=1744894970625"
+        self.cookie = f"__vtins__KUc0LhjVWFNXQv11=%7B%22sid%22%3A%20%{uuid.uuid4().hex}%22%2C%20%22vd%22%3A%201%2C%20%22stt%22%3A%200%2C%20%22dr%22%3A%200%2C%20%22expires%22%3A%201744896723481%2C%20%22ct%22%3A%201744894923481%7D; __51uvsct__KUc0LhjVWFNXQv11=1; __51vcke__KUc0LhjVWFNXQv11=06da852c-bb56-547c-91a8-43a0d485ffed; __51vuft__KUc0LhjVWFNXQv11=1744894923504; gfsessionid=1ochrgv17vy4sbd98xmwt6crpmkxwlqf; oai-nav-state=1; p_uv_id=ad86646801bc60d6d95f6098e4ee7450; _dd_s=rum=0&expire=1744895920821&logs=1&id={uuid.uuid4().hex}&created={int(datetime.utcnow().timestamp() * 1000)}"
 
         # Initialize chat interface
         self.chat = Chat(self)
@@ -494,3 +509,11 @@ class OPKFC(OpenAICompatibleProvider):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
 
+if __name__ == "__main__":
+    # Example usage
+    client = OPKFC()
+    response = client.chat.completions.create(
+        model="auto",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.choices[0].message.content)

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(
@@ -332,12 +338,13 @@ class SciraChat(OpenAICompatibleProvider):
     AVAILABLE_MODELS = {
         "scira-default": "Grok3-mini", # thinking model
         "scira-grok-3": "Grok3",
-        "scira-anthropic": "Sonnet 3.7 thinking",
+        "scira-anthropic": "Claude 4 Sonnet",
+        "scira-anthropic-thinking": "Claude 4 Sonnet Thinking", # thinking model
         "scira-vision" : "Grok2-Vision", # vision model
         "scira-4o": "GPT4o",
         "scira-qwq": "QWQ-32B",
         "scira-o4-mini": "o4-mini",
-        "scira-google": "gemini 2.5 flash",
+        "scira-google": "gemini 2.5 flash Thinking", # thinking model
         "scira-google-pro": "gemini 2.5 pro",
         "scira-llama-4": "llama 4 Maverick",
     }

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()
-

webscout/Provider/OPENAI/toolbaz.py

@@ -10,8 +10,8 @@ from datetime import datetime
 from typing import List, Dict, Optional, Union, Generator, Any
 
 from webscout.litagent import LitAgent
-from .base import BaseChat, BaseCompletions, OpenAICompatibleProvider
-from .utils import (
+from webscout.Provider.OPENAI.base import BaseChat, BaseCompletions, OpenAICompatibleProvider
+from webscout.Provider.OPENAI.utils import (
     ChatCompletion,
     ChatCompletionChunk,
     Choice,
@@ -40,6 +40,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]]:
         """
@@ -68,16 +70,18 @@ class Completions(BaseCompletions):
 
         # Handle streaming response
         if stream:
-            return self._handle_streaming_response(request_id, created_time, model, data)
+            return self._handle_streaming_response(request_id, created_time, model, data, timeout, proxies)
         else:
-            return self._handle_non_streaming_response(request_id, created_time, model, data)
+            return self._handle_non_streaming_response(request_id, created_time, model, data, timeout, proxies)
 
     def _handle_streaming_response(
         self,
         request_id: str,
         created_time: int,
         model: str,
-        data: Dict[str, Any]
+        data: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Handle streaming response from Toolbaz API"""
         try:
@@ -85,8 +89,8 @@ class Completions(BaseCompletions):
                 "https://data.toolbaz.com/writing.php",
                 data=data,
                 stream=True,
-                proxies=self._client.proxies,
-                timeout=self._client.timeout
+                proxies=proxies or getattr(self._client, "proxies", None),
+                timeout=timeout or self._client.timeout
             )
             resp.raise_for_status()
 
@@ -219,15 +223,17 @@ class Completions(BaseCompletions):
         request_id: str,
         created_time: int,
         model: str,
-        data: Dict[str, Any]
+        data: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Handle non-streaming response from Toolbaz API"""
         try:
             resp = self._client.session.post(
                 "https://data.toolbaz.com/writing.php",
                 data=data,
-                proxies=self._client.proxies,
-                timeout=self._client.timeout
+                proxies=proxies or getattr(self._client, "proxies", None),
+                timeout=timeout or self._client.timeout
             )
             resp.raise_for_status()
 
@@ -296,7 +302,6 @@ class Toolbaz(OpenAICompatibleProvider):
         "Llama-4-Scout",
         "Llama-3.3-70B",
         "Qwen2.5-72B",
-        "Qwen2-72B",
         "grok-2-1212",
         "grok-3-beta",
         "toolbaz_v3.5_pro",

webscout/Provider/OPENAI/typefully.py

@@ -36,6 +36,8 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         stream: bool = False,
         temperature: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -67,16 +69,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:
@@ -86,7 +90,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="chrome120"
             )
 
@@ -161,7 +166,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:
@@ -171,7 +178,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="chrome120"
             )
 
@@ -352,4 +360,3 @@ class TypefullyAI(OpenAICompatibleProvider):
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-

webscout/Provider/OPENAI/typegpt.py

@@ -34,6 +34,8 @@ class Completions(BaseCompletions):
         top_p: Optional[float] = None,
         presence_penalty: Optional[float] = None,
         frequency_penalty: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> 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, 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(
@@ -74,7 +76,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
@@ -209,14 +212,15 @@ class Completions(BaseCompletions):
             raise IOError(f"TypeGPT 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