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

webscout/Provider/OPENAI/TwoAI.py

@@ -39,6 +39,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 using TwoAI."""
@@ -59,19 +61,26 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, payload)
-        return self._create_non_stream(request_id, created_time, model, payload)
+            return self._create_stream(request_id, created_time, model, payload, timeout=timeout, proxies=proxies)
+        return self._create_non_stream(request_id, created_time, model, payload, timeout=timeout, proxies=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]:
+        original_proxies = self._client.session.proxies.copy()
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
             response = self._client.session.post(
                 self._client.base_url,
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout,
+                timeout=timeout if timeout is not None else self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -129,18 +138,25 @@ class Completions(BaseCompletions):
                 yield chunk
         except Exception as e:
             raise IOError(f"TwoAI request failed: {e}") from e
-        except Exception as e:
-            raise IOError(f"Error processing TwoAI stream: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
     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:
+        original_proxies = self._client.session.proxies.copy()
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
             response = self._client.session.post(
                 self._client.base_url,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout,
+                timeout=timeout if timeout is not None else self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
             data = response.json()
@@ -179,8 +195,8 @@ class Completions(BaseCompletions):
             return completion
         except Exception as e:
             raise IOError(f"TwoAI request failed: {e}") from e
-        except Exception as e:
-            raise IOError(f"Error processing TwoAI response: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
 
 class Chat(BaseChat):
@@ -285,12 +301,13 @@ class TwoAI(OpenAICompatibleProvider):
             raise RuntimeError("Failed to get API key from confirmation email")
         return api_key
 
-    def __init__(self, timeout: Optional[int] = None, browser: str = "chrome"):
+    def __init__(self, browser: str = "chrome"):
         api_key = self.generate_api_key()
-        self.timeout = timeout
+        self.timeout = 30
         self.base_url = "https://api.two.ai/v2/chat/completions"
         self.api_key = api_key
         self.session = Session()
+        self.session.proxies = {}
 
         headers: Dict[str, str] = {
             "Content-Type": "application/json",

webscout/Provider/OPENAI/__init__.py

@@ -37,4 +37,6 @@ from .BLACKBOXAI import *
 from .copilot import * # Add Microsoft Copilot
 from .TwoAI import *
 from .oivscode import * # Add OnRender provider
-from .Qwen3 import *
+from .Qwen3 import *
+from .FalconH1 import *
+from .PI import *  # Add PI.ai provider

webscout/Provider/OPENAI/ai4chat.py

@@ -26,6 +26,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -48,18 +50,19 @@ class Completions(BaseCompletions):
 
         # AI4Chat doesn't support streaming, so we'll simulate it if requested
         if stream:
-            return self._create_stream(request_id, created_time, model, conversation_prompt, country_param, user_id_param)
+            return self._create_stream(request_id, created_time, model, conversation_prompt, country_param, user_id_param, timeout=timeout, proxies=proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, conversation_prompt, country_param, user_id_param)
+            return self._create_non_stream(request_id, created_time, model, conversation_prompt, country_param, user_id_param, timeout=timeout, proxies=proxies)
 
     def _create_stream(
         self, request_id: str, created_time: int, model: str,
-        conversation_prompt: str, country: str, user_id: str
+        conversation_prompt: str, country: str, user_id: str,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Simulate streaming by breaking up the full response into fixed-size character chunks."""
         try:
             # Get the full response first
-            full_response = self._get_ai4chat_response(conversation_prompt, country, user_id)
+            full_response = self._get_ai4chat_response(conversation_prompt, country, user_id, timeout=timeout, proxies=proxies)
 
             # Track token usage
             prompt_tokens = count_tokens(conversation_prompt)
@@ -133,12 +136,13 @@ class Completions(BaseCompletions):
 
     def _create_non_stream(
         self, request_id: str, created_time: int, model: str,
-        conversation_prompt: str, country: str, user_id: str
+        conversation_prompt: str, country: str, user_id: str,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> ChatCompletion:
         """Get a complete response from AI4Chat."""
         try:
             # Get the full response
-            full_response = self._get_ai4chat_response(conversation_prompt, country, user_id)
+            full_response = self._get_ai4chat_response(conversation_prompt, country, user_id, timeout=timeout, proxies=proxies)
 
             # Estimate token counts
             prompt_tokens = count_tokens(conversation_prompt)
@@ -183,22 +187,31 @@ class Completions(BaseCompletions):
             print(f"Unexpected error during AI4Chat non-stream request: {e}")
             raise IOError(f"AI4Chat request failed: {e}") from e
 
-    def _get_ai4chat_response(self, prompt: str, country: str, user_id: str) -> str:
+    def _get_ai4chat_response(self, prompt: str, country: str, user_id: str,
+                               timeout: Optional[int] = None, proxies: Optional[dict] = None) -> str:
         """Make the actual API request to AI4Chat."""
-        # URL encode parameters
-        encoded_text = urllib.parse.quote(prompt)
-        encoded_country = urllib.parse.quote(country)
-        encoded_user_id = urllib.parse.quote(user_id)
+        timeout_val = timeout if timeout is not None else self._client.timeout
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        
+        try:
+            # URL encode parameters
+            encoded_text = urllib.parse.quote(prompt)
+            encoded_country = urllib.parse.quote(country)
+            encoded_user_id = urllib.parse.quote(user_id)
 
-        # Construct the API URL
-        url = f"{self._client.api_endpoint}?text={encoded_text}&country={encoded_country}&user_id={encoded_user_id}"
+            # Construct the API URL
+            url = f"{self._client.api_endpoint}?text={encoded_text}&country={encoded_country}&user_id={encoded_user_id}"
 
-        # Make the request
-        try:
-            response = self._client.session.get(url, headers=self._client.headers, timeout=self._client.timeout)
+            # Make the request
+            response = self._client.session.get(url, headers=self._client.headers, timeout=timeout_val)
             response.raise_for_status()
         except RequestsError as e:
             raise IOError(f"Failed to generate response: {e}")
+        finally:
+            if proxies is not None:
+                self._client.session.proxies = original_proxies
 
         # Process the response text
         response_text = response.text
@@ -235,8 +248,6 @@ class AI4Chat(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: int = 30,
-        proxies: dict = {},
         system_prompt: str = "You are a helpful and informative AI assistant.",
         country: str = "Asia",
         user_id: str = "usersmjb2oaz7y"
@@ -245,14 +256,11 @@ class AI4Chat(OpenAICompatibleProvider):
         Initialize the AI4Chat client.
 
         Args:
-            timeout: Request timeout in seconds
-            proxies: Optional proxy configuration
             system_prompt: System prompt to guide the AI's behavior
             country: Country parameter for API
             user_id: User ID for API
         """
-        self.timeout = timeout
-        self.proxies = proxies
+        self.timeout = 30
         self.system_prompt = system_prompt
         self.country = country
         self.user_id = user_id
@@ -261,7 +269,9 @@ class AI4Chat(OpenAICompatibleProvider):
         self.api_endpoint = "https://yw85opafq6.execute-api.us-east-1.amazonaws.com/default/boss_mode_15aug"
 
         # Initialize session
-        self.session = Session(timeout=timeout, proxies=proxies)
+        self.session = Session()
+        self.session.proxies = {}
+        # self.session.timeout = self.timeout # Timeout is per-request for curl_cffi
 
         # Set headers
         self.headers = {

webscout/Provider/OPENAI/api.py

@@ -16,6 +16,8 @@ import sys
 import time
 import uuid
 import inspect
+import re
+import codecs
 from typing import List, Dict, Optional, Union, Any, Generator, Callable
 import types
 
@@ -28,6 +30,18 @@ from fastapi.routing import APIRoute
 from fastapi.exceptions import RequestValidationError
 from fastapi.security import APIKeyHeader
 from starlette.exceptions import HTTPException as StarletteHTTPException
+
+def clean_text(text):
+    """Clean text by removing null bytes and control characters except newlines and tabs."""
+    if not isinstance(text, str):
+        return text
+    
+    # Remove null bytes
+    text = text.replace('\x00', '')
+    
+    # Keep newlines, tabs, and other printable characters, remove other control chars
+    # This regex matches control characters except \n, \r, \t
+    return re.sub(r'[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
 from starlette.status import (
     HTTP_422_UNPROCESSABLE_ENTITY,
     HTTP_404_NOT_FOUND,
@@ -153,7 +167,7 @@ class ChatCompletionRequest(BaseModel):
         extra = "ignore"  # Ignore extra fields that aren't in the model
         schema_extra = {
             "example": {
-                "model": "ChatGPT/gpt-4",
+                "model": "ChatGPT/gpt-4o",
                 "messages": [
                     {"role": "system", "content": "You are a helpful assistant."},
                     {"role": "user", "content": "Hello, how are you?"}
@@ -634,7 +648,16 @@ def resolve_provider_and_model(model_identifier: str) -> tuple[Any, str]:
 
     # Validate model availability
     if hasattr(provider_class, "AVAILABLE_MODELS") and model_name is not None:
-        available = getattr(provider_class, "AVAILABLE_MODELS", [])
+        available = getattr(provider_class, "AVAILABLE_MODELS", None)
+        # If it's a property, get from instance
+        if isinstance(available, property):
+            try:
+                available = getattr(provider_class(), "AVAILABLE_MODELS", [])
+            except Exception:
+                available = []
+        # If still not iterable, fallback to empty list
+        if not isinstance(available, (list, tuple, set)):
+            available = list(available) if hasattr(available, "__iter__") and not isinstance(available, str) else []
         if available and model_name not in available:
             raise APIError(
                 f"Model '{model_name}' not supported by provider '{provider_class.__name__}'. Available models: {available}",
@@ -722,34 +745,69 @@ async def handle_streaming_response(provider: Any, params: Dict[str, Any], reque
                             chunk_data = chunk
                         else:  # Fallback for unknown chunk types
                             chunk_data = chunk
-                        yield f"data: {json.dumps(chunk_data)}\n\n"
+                        
+                        # Clean text content in the chunk to remove control characters
+                        if isinstance(chunk_data, dict) and 'choices' in chunk_data:
+                            for choice in chunk_data.get('choices', []):
+                                if isinstance(choice, dict):
+                                    # Handle delta for streaming
+                                    if 'delta' in choice and isinstance(choice['delta'], dict) and 'content' in choice['delta']:
+                                        choice['delta']['content'] = clean_text(choice['delta']['content'])
+                                    # Handle message for non-streaming
+                                    elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                                        choice['message']['content'] = clean_text(choice['message']['content'])
+                        
+                        yield f"data: {json.dumps(chunk_data, ensure_ascii=False)}\n\n"
                 except TypeError as te:
                     logger.error(f"Error iterating over completion_stream: {te}")
                     # Fall back to treating as non-generator response
                     if hasattr(completion_stream, 'model_dump'):
-                        yield f"data: {json.dumps(completion_stream.model_dump(exclude_none=True))}\n\n"
+                        response_data = completion_stream.model_dump(exclude_none=True)
                     elif hasattr(completion_stream, 'dict'):
-                        yield f"data: {json.dumps(completion_stream.dict(exclude_none=True))}\n\n"
+                        response_data = completion_stream.dict(exclude_none=True)
                     else:
-                        yield f"data: {json.dumps(completion_stream)}\n\n"
+                        response_data = completion_stream
+                    
+                    # Clean text content in the response
+                    if isinstance(response_data, dict) and 'choices' in response_data:
+                        for choice in response_data.get('choices', []):
+                            if isinstance(choice, dict):
+                                if 'delta' in choice and isinstance(choice['delta'], dict) and 'content' in choice['delta']:
+                                    choice['delta']['content'] = clean_text(choice['delta']['content'])
+                                elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                                    choice['message']['content'] = clean_text(choice['message']['content'])
+                    
+                    yield f"data: {json.dumps(response_data, ensure_ascii=False)}\n\n"
             else:  # Non-generator response
                 if hasattr(completion_stream, 'model_dump'):
-                    yield f"data: {json.dumps(completion_stream.model_dump(exclude_none=True))}\n\n"
+                    response_data = completion_stream.model_dump(exclude_none=True)
                 elif hasattr(completion_stream, 'dict'):
-                    yield f"data: {json.dumps(completion_stream.dict(exclude_none=True))}\n\n"
+                    response_data = completion_stream.dict(exclude_none=True)
                 else:
-                    yield f"data: {json.dumps(completion_stream)}\n\n"
+                    response_data = completion_stream
+                
+                # Clean text content in the response
+                if isinstance(response_data, dict) and 'choices' in response_data:
+                    for choice in response_data.get('choices', []):
+                        if isinstance(choice, dict):
+                            if 'delta' in choice and isinstance(choice['delta'], dict) and 'content' in choice['delta']:
+                                choice['delta']['content'] = clean_text(choice['delta']['content'])
+                            elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                                choice['message']['content'] = clean_text(choice['message']['content'])
+                
+                yield f"data: {json.dumps(response_data, ensure_ascii=False)}\n\n"
 
         except Exception as e:
             logger.error(f"Error in streaming response for request {request_id}: {e}")
+            error_message = clean_text(str(e))
             error_data = {
                 "error": {
-                    "message": str(e),
+                    "message": error_message,
                     "type": "server_error",
                     "code": "streaming_error"
                 }
             }
-            yield f"data: {json.dumps(error_data)}\n\n"
+            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
         finally:
             yield "data: [DONE]\n\n"
     return StreamingResponse(streaming(), media_type="text/event-stream")
@@ -789,6 +847,13 @@ async def handle_non_streaming_response(provider: Any, params: Dict[str, Any],
                 HTTP_500_INTERNAL_SERVER_ERROR,
                 "provider_error"
             )
+        
+        # Clean text content in the response to remove control characters
+        if isinstance(response_data, dict) and 'choices' in response_data:
+            for choice in response_data.get('choices', []):
+                if isinstance(choice, dict) and 'message' in choice:
+                    if isinstance(choice['message'], dict) and 'content' in choice['message']:
+                        choice['message']['content'] = clean_text(choice['message']['content'])
 
         elapsed = time.time() - start_time
         logger.info(f"Completed non-streaming request {request_id} in {elapsed:.2f}s")
@@ -797,8 +862,9 @@ async def handle_non_streaming_response(provider: Any, params: Dict[str, Any],
 
     except Exception as e:
         logger.error(f"Error in non-streaming response for request {request_id}: {e}")
+        error_message = clean_text(str(e))
         raise APIError(
-            f"Provider error: {str(e)}",
+            f"Provider error: {error_message}",
             HTTP_500_INTERNAL_SERVER_ERROR,
             "provider_error"
         )

webscout/Provider/OPENAI/base.py

@@ -78,6 +78,8 @@ class BaseCompletions(ABC):
         top_p: Optional[float] = None,
         tools: Optional[List[Union[Tool, Dict[str, Any]]]] = None,  # Support for tool definitions
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,  # Support for tool_choice parameter
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """

webscout/Provider/OPENAI/c4ai.py

@@ -49,6 +49,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -88,14 +90,21 @@ class Completions(BaseCompletions):
 
         # Pass the formatted conversation prompt
         if stream:
-            return self._create_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt)
+            return self._create_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt, timeout=timeout, proxies=proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt)
+            return self._create_non_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt, timeout=timeout, proxies=proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str
+        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
+            timeout_val = timeout if timeout is not None else self._client.timeout
             message_id = self._client._conversation_data[model]["messageId"]
             url = f"{self._client.url}/api/chat/message"
             payload = {
@@ -117,7 +126,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout_val,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -160,11 +170,20 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"Error during C4AI stream request: {e}")
             raise IOError(f"C4AI request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str
+        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> ChatCompletion:
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
+            timeout_val = timeout if timeout is not None else self._client.timeout
             message_id = self._client._conversation_data[model]["messageId"]
             url = f"{self._client.url}/api/chat/message"
             payload = {
@@ -185,7 +204,8 @@ class Completions(BaseCompletions):
                 url,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout_val,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -213,6 +233,8 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"Error during C4AI non-stream request: {e}")
             raise IOError(f"C4AI request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
 class Chat(BaseChat):
     def __init__(self, client: 'C4AI'):
@@ -242,19 +264,18 @@ class C4AI(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: Optional[int] = None,
         browser: str = "chrome"
     ):
         """
         Initialize the C4AI client.
 
         Args:
-            timeout: Request timeout in seconds.
             browser: Browser name for LitAgent to generate User-Agent.
         """
-        self.timeout = timeout
+        self.timeout = 30
         self.url = "https://cohereforai-c4ai-command.hf.space"
         self.session = requests.Session()
+        self.session.proxies = {}
         self.max_tokens_to_sample = 2000
 
         agent = LitAgent()
@@ -370,4 +391,4 @@ class C4AI(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()

webscout/Provider/OPENAI/chatgpt.py

@@ -9,8 +9,8 @@ from datetime import datetime, timedelta
 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
 )
@@ -21,9 +21,21 @@ RED = "\033[91m"
 RESET = "\033[0m"
 
 class ChatGPTReversed:
+    AVAILABLE_MODELS = [
+        "auto", 
+        "gpt-4o-mini", 
+        "gpt-4o", 
+        "o4-mini",
+        "gpt-4-1",
+        "gpt-4-1-mini",
+        "o3",
+        "o4-mini-high"
+
+
+
+    ]
     csrf_token = None
     initialized = False
-    AVAILABLE_MODELS = ["auto", "gpt-4o-mini", "gpt-4o", "o4-mini"]
 
     def __init__(self, model="auto"):
         if ChatGPTReversed.initialized:
@@ -332,6 +344,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -362,6 +376,8 @@ class Completions(BaseCompletions):
                 max_tokens=max_tokens,
                 temperature=temperature,
                 top_p=top_p,
+                timeout=timeout,
+                proxies=proxies,
                 **kwargs
             )
         
@@ -372,6 +388,8 @@ class Completions(BaseCompletions):
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
+            timeout=timeout,
+            proxies=proxies,
             **kwargs
         )
 
@@ -383,6 +401,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] = None,
         **kwargs: Any
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Implementation for streaming chat completions."""
@@ -448,6 +468,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] = None,
         **kwargs: Any
     ) -> ChatCompletion:
         """Implementation for non-streaming chat completions."""
@@ -523,34 +545,31 @@ class ChatGPT(OpenAICompatibleProvider):
         print(response.choices[0].message.content)
     """
 
-    AVAILABLE_MODELS = [
-        "auto", 
-        "gpt-4o-mini", 
-        "gpt-4o", 
-        "o4-mini"
-    ]
-
     def __init__(
-        self,
-        timeout: int = 60,
-        proxies: dict = {}
+        self
     ):
         """
         Initialize the ChatGPT client.
-
-        Args:
-            timeout: Request timeout in seconds
-            proxies: Optional proxy configuration
         """
-        self.timeout = timeout
-        self.proxies = proxies
-        
         # Initialize chat interface
         self.chat = Chat(self)
 
+    @property
+    def AVAILABLE_MODELS(self):
+        return ChatGPTReversed.AVAILABLE_MODELS
+
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
-                return type(self).AVAILABLE_MODELS
-        return _ModelList()
+                return ChatGPTReversed.AVAILABLE_MODELS
+        return _ModelList()
+
+if __name__ == "__main__":
+    # Example usage
+    client = ChatGPT()
+    response = client.chat.completions.create(
+        model="o4-mini-high",
+        messages=[{"role": "user", "content": "How manr r in strawberry"}]
+    )
+    print(response.choices[0].message.content)