camel-ai 0.2.66__py3-none-any.whl → 0.2.68__py3-none-any.whl

camel/models/gemini_model.py

@@ -64,6 +64,10 @@ class GeminiModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -79,6 +83,8 @@ class GeminiModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = GeminiConfig().as_dict()
@@ -95,6 +101,8 @@ class GeminiModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _process_messages(self, messages) -> List[OpenAIMessage]:

camel/models/groq_model.py

@@ -45,6 +45,10 @@ class GroqModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required([("api_key", "GROQ_API_KEY")])
@@ -56,6 +60,8 @@ class GroqModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = GroqConfig().as_dict()
@@ -71,6 +77,8 @@ class GroqModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/internlm_model.py

@@ -54,6 +54,10 @@ class InternLMModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -69,6 +73,8 @@ class InternLMModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         self.model_config = model_config_dict or InternLMConfig().as_dict()
         api_key = api_key or os.environ.get("INTERNLM_API_KEY")
@@ -84,6 +90,8 @@ class InternLMModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     async def _arun(

camel/models/litellm_model.py

@@ -59,6 +59,8 @@ class LiteLLMModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     # NOTE: Currently stream mode is not supported.
@@ -72,6 +74,7 @@ class LiteLLMModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> None:
         from litellm import completion
 
@@ -82,6 +85,7 @@ class LiteLLMModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self.client = completion
+        self.kwargs = kwargs
 
     def _convert_response_from_litellm_to_openai(
         self, response
@@ -173,6 +177,7 @@ class LiteLLMModel(BaseModelBackend):
             model=self.model_type,
             messages=messages,
             **self.model_config_dict,
+            **self.kwargs,
         )
         response = self._convert_response_from_litellm_to_openai(response)
 

camel/models/lmstudio_model.py

@@ -43,6 +43,10 @@ class LMStudioModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     def __init__(
@@ -53,6 +57,8 @@ class LMStudioModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = LMStudioConfig().as_dict()
@@ -62,7 +68,14 @@ class LMStudioModel(OpenAICompatibleModel):
         )
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter, timeout
+            model_type,
+            model_config_dict,
+            api_key,
+            url,
+            token_counter,
+            timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/mistral_model.py

@@ -80,6 +80,10 @@ class MistralModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries
+            for API calls. (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -96,6 +100,8 @@ class MistralModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         from mistralai import Mistral
 
@@ -106,7 +112,14 @@ class MistralModel(BaseModelBackend):
         url = url or os.environ.get("MISTRAL_API_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter, timeout
+            model_type,
+            model_config_dict,
+            api_key,
+            url,
+            token_counter,
+            timeout,
+            max_retries,
+            **kwargs,
         )
         self._client = Mistral(
             timeout_ms=int(self._timeout * 1000)
@@ -114,6 +127,7 @@ class MistralModel(BaseModelBackend):
             else None,
             api_key=self._api_key,
             server_url=self._url,
+            **kwargs,
         )
 
     def _to_openai_response(

camel/models/model_factory.py

@@ -39,6 +39,7 @@ from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.openrouter_model import OpenRouterModel
 from camel.models.ppio_model import PPIOModel
+from camel.models.qianfan_model import QianfanModel
 from camel.models.qwen_model import QwenModel
 from camel.models.reka_model import RekaModel
 from camel.models.samba_model import SambaModel
@@ -98,6 +99,7 @@ class ModelFactory:
         ModelPlatformType.MODELSCOPE: ModelScopeModel,
         ModelPlatformType.NOVITA: NovitaModel,
         ModelPlatformType.WATSONX: WatsonXModel,
+        ModelPlatformType.QIANFAN: QianfanModel,
         ModelPlatformType.CRYNUX: CrynuxModel,
     }
 
@@ -110,6 +112,7 @@ class ModelFactory:
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
         **kwargs,
     ) -> BaseModelBackend:
         r"""Creates an instance of `BaseModelBackend` of the specified type.
@@ -134,6 +137,8 @@ class ModelFactory:
                 (default: :obj:`None`)
             timeout (Optional[float], optional): The timeout value in seconds
                 for API calls. (default: :obj:`None`)
+            max_retries (int, optional): Maximum number of retries
+                for API calls. (default: :obj:`3`)
             **kwargs: Additional model-specific parameters that will be passed
                 to the model constructor. For example, Azure OpenAI models may
                 require `api_version`, `azure_deployment_name`,
@@ -186,6 +191,7 @@ class ModelFactory:
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
             **kwargs,
         )
 

camel/models/modelscope_model.py

@@ -56,6 +56,10 @@ class ModelScopeModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -71,6 +75,8 @@ class ModelScopeModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ModelScopeConfig().as_dict()
@@ -87,6 +93,8 @@ class ModelScopeModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _post_handle_response(

camel/models/moonshot_model.py

@@ -54,6 +54,10 @@ class MoonshotModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required([("api_key", "MOONSHOT_API_KEY")])
@@ -65,6 +69,8 @@ class MoonshotModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = MoonshotConfig().as_dict()
@@ -81,6 +87,8 @@ class MoonshotModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     async def _arun(

camel/models/nemotron_model.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
@@ -36,6 +36,10 @@ class NemotronModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
 
     Notes:
         Nemotron model doesn't support additional model config like OpenAI.
@@ -52,13 +56,24 @@ class NemotronModel(OpenAICompatibleModel):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         url = url or os.environ.get(
             "NVIDIA_API_BASE_URL", "https://integrate.api.nvidia.com/v1"
         )
         api_key = api_key or os.environ.get("NVIDIA_API_KEY")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
-        super().__init__(model_type, {}, api_key, url, None, timeout)
+        super().__init__(
+            model_type,
+            {},
+            api_key,
+            url,
+            None,
+            timeout,
+            max_retries=max_retries,
+            **kwargs,
+        )
 
     @property
     def token_counter(self) -> BaseTokenCounter:

camel/models/netmind_model.py

@@ -47,6 +47,10 @@ class NetmindModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -62,6 +66,8 @@ class NetmindModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = NetmindConfig().as_dict()
@@ -78,6 +84,8 @@ class NetmindModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/novita_model.py

@@ -47,6 +47,10 @@ class NovitaModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -62,6 +66,8 @@ class NovitaModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = NovitaConfig().as_dict()
@@ -77,6 +83,8 @@ class NovitaModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/nvidia_model.py

@@ -43,6 +43,10 @@ class NvidiaModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -58,6 +62,8 @@ class NvidiaModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = NvidiaConfig().as_dict()
@@ -73,6 +79,8 @@ class NvidiaModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/ollama_model.py

@@ -47,6 +47,10 @@ class OllamaModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
 
     References:
         https://github.com/ollama/ollama/blob/main/docs/openai.md
@@ -60,6 +64,8 @@ class OllamaModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = OllamaConfig().as_dict()
@@ -77,6 +83,8 @@ class OllamaModel(OpenAICompatibleModel):
             url=self._url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _start_server(self) -> None:

camel/models/openai_compatible_model.py

@@ -67,6 +67,11 @@ class OpenAICompatibleModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the
+            OpenAI client initialization. These can include parameters like
+            'organization', 'default_headers', 'http_client', etc.
     """
 
     def __init__(
@@ -77,12 +82,21 @@ class OpenAICompatibleModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         api_key = api_key or os.environ.get("OPENAI_COMPATIBILITY_API_KEY")
         url = url or os.environ.get("OPENAI_COMPATIBILITY_API_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter, timeout
+            model_type,
+            model_config_dict,
+            api_key,
+            url,
+            token_counter,
+            timeout,
+            max_retries,
         )
         if is_langfuse_available():
             from langfuse.openai import AsyncOpenAI as LangfuseAsyncOpenAI
@@ -90,28 +104,32 @@ class OpenAICompatibleModel(BaseModelBackend):
 
             self._client = LangfuseOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
             self._async_client = LangfuseAsyncOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
         else:
             self._client = OpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
             self._async_client = AsyncOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
 
     @observe()

camel/models/openai_model.py

@@ -76,6 +76,11 @@ class OpenAIModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the
+            OpenAI client initialization. These can include parameters like
+            'organization', 'default_headers', 'http_client', etc.
     """
 
     @api_keys_required(
@@ -91,6 +96,8 @@ class OpenAIModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
@@ -98,6 +105,9 @@ class OpenAIModel(BaseModelBackend):
         url = url or os.environ.get("OPENAI_API_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
 
+        # Store additional client args for later use
+        self._max_retries = max_retries
+
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
@@ -106,30 +116,37 @@ class OpenAIModel(BaseModelBackend):
             from langfuse.openai import AsyncOpenAI as LangfuseAsyncOpenAI
             from langfuse.openai import OpenAI as LangfuseOpenAI
 
+            # Create Langfuse client with base parameters and additional
+            # arguments
             self._client = LangfuseOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=self._max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
             self._async_client = LangfuseAsyncOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=self._max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
         else:
+            # Create client with base parameters and additional arguments
             self._client = OpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=self._max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
             self._async_client = AsyncOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=self._max_retries,
                 base_url=self._url,
                 api_key=self._api_key,
+                **kwargs,
             )
 
     def _sanitize_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:

camel/models/openrouter_model.py

@@ -46,6 +46,10 @@ class OpenRouterModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required([("api_key", "OPENROUTER_API_KEY")])
@@ -57,6 +61,8 @@ class OpenRouterModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = OpenRouterConfig().as_dict()
@@ -72,6 +78,8 @@ class OpenRouterModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/ppio_model.py

@@ -47,6 +47,10 @@ class PPIOModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -62,6 +66,8 @@ class PPIOModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = PPIOConfig().as_dict()
@@ -77,6 +83,8 @@ class PPIOModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):