camel-ai 0.2.65__py3-none-any.whl → 0.2.67__py3-none-any.whl

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

camel/models/qianfan_model.py

@@ -0,0 +1,104 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import os
+from typing import Any, Dict, Optional, Union
+
+from camel.configs import QIANFAN_API_PARAMS, QianfanConfig
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    api_keys_required,
+)
+
+
+class QianfanModel(OpenAICompatibleModel):
+    r"""Constructor for Qianfan backend with OpenAI compatibility.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, supported model can be found here:
+            https://cloud.baidu.com/doc/QIANFANWORKSHOP/s/Wm9cvy6rl
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`QianfanConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Qianfan service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Qianfan service.
+            If not provided, "https://qianfan.baidubce.com/v2/chat/completions"
+            will be used.(default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+        max_retries (Optional[int], optional): Maximum number of retries
+            for API calls. (default: :obj:`None`)
+        **kwargs: Additional model-specific parameters that will be passed
+            to the model constructor.
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'QIANFAN_API_KEY'),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = QianfanConfig().as_dict()
+        api_key = api_key or os.environ.get("QIANFAN_API_KEY")
+        url = url or os.environ.get(
+            "QIANFAN_API_BASE_URL",
+            "https://qianfan.baidubce.com/v2",
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type=model_type,
+            model_config_dict=model_config_dict,
+            api_key=api_key,
+            url=url,
+            token_counter=token_counter,
+            timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
+        )
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Qianfan API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Qianfan API.
+        """
+        for param in self.model_config_dict:
+            if param not in QIANFAN_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into QIANFAN model backend."
+                )

camel/models/qwen_model.py

@@ -54,6 +54,10 @@ class QwenModel(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 QwenModel(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 = QwenConfig().as_dict()
@@ -85,6 +91,8 @@ class QwenModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _post_handle_response(

camel/models/reka_model.py

@@ -72,6 +72,8 @@ class RekaModel(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.
     """
 
     @api_keys_required(
@@ -88,6 +90,7 @@ class RekaModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> None:
         from reka.client import AsyncReka, Reka
 
@@ -97,13 +100,25 @@ class RekaModel(BaseModelBackend):
         url = url or os.environ.get("REKA_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,
+            **kwargs,
         )
         self._client = Reka(
-            api_key=self._api_key, base_url=self._url, timeout=self._timeout
+            api_key=self._api_key,
+            base_url=self._url,
+            timeout=self._timeout,
+            **kwargs,
         )
         self._async_client = AsyncReka(
-            api_key=self._api_key, base_url=self._url, timeout=self._timeout
+            api_key=self._api_key,
+            base_url=self._url,
+            timeout=self._timeout,
+            **kwargs,
         )
 
     def _convert_reka_to_openai_response(

camel/models/samba_model.py

@@ -88,6 +88,10 @@ class SambaModel(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(
@@ -103,6 +107,8 @@ class SambaModel(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 = SambaCloudAPIConfig().as_dict()
@@ -113,21 +119,29 @@ class SambaModel(BaseModelBackend):
         )
         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 self._url == "https://api.sambanova.ai/v1":
             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,
             )
 
     @property