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

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.65'
+__version__ = '0.2.67'
 
 __all__ = [
     '__version__',

camel/agents/mcp_agent.py

@@ -125,7 +125,6 @@ class MCPAgent(ChatAgent):
         local_config_path: Optional[str] = None,
         tools: Optional[List[Union[FunctionTool, Callable]]] = None,
         function_calling_available: bool = True,
-        strict: bool = False,
         **kwargs,
     ):
         if model is None:
@@ -145,7 +144,6 @@ class MCPAgent(ChatAgent):
 
         self.local_config = local_config
         self.function_calling_available = function_calling_available
-        self.strict = strict
 
         if function_calling_available:
             sys_msg_content = "You are a helpful assistant, and you prefer "
@@ -179,7 +177,7 @@ class MCPAgent(ChatAgent):
         if self.local_config:
             config_dict.update(self.local_config)
 
-        return MCPToolkit(config_dict=config_dict, strict=self.strict)
+        return MCPToolkit(config_dict=config_dict)
 
     def add_registry(self, registry_config: BaseMCPRegistryConfig) -> None:
         r"""Add a new registry configuration to the agent.
@@ -213,7 +211,6 @@ class MCPAgent(ChatAgent):
         ] = None,
         model: Optional[BaseModelBackend] = None,
         function_calling_available: bool = False,
-        strict: bool = False,
         **kwargs,
     ) -> "MCPAgent":
         r"""Create and connect an MCPAgent instance.
@@ -279,7 +276,6 @@ class MCPAgent(ChatAgent):
             registry_configs=final_registry_configs,
             model=model,
             function_calling_available=function_calling_available,
-            strict=strict,
             **kwargs,
         )
 

camel/configs/__init__.py

@@ -33,6 +33,7 @@ from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
 from .openrouter_config import OPENROUTER_API_PARAMS, OpenRouterConfig
 from .ppio_config import PPIO_API_PARAMS, PPIOConfig
+from .qianfan_config import QIANFAN_API_PARAMS, QianfanConfig
 from .qwen_config import QWEN_API_PARAMS, QwenConfig
 from .reka_config import REKA_API_PARAMS, RekaConfig
 from .samba_config import (
@@ -113,6 +114,8 @@ __all__ = [
     'LMStudioConfig',
     'WatsonXConfig',
     'WATSONX_API_PARAMS',
+    'QianfanConfig',
+    'QIANFAN_API_PARAMS',
     'CrynuxConfig',
     'CRYNUX_API_PARAMS',
 ]

camel/configs/qianfan_config.py

@@ -0,0 +1,85 @@
+# ========= 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. =========
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Union
+
+from pydantic import Field
+
+from camel.configs.base_config import BaseConfig
+from camel.types import NotGiven
+
+
+class QianfanConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility.
+
+    Reference: https://cloud.baidu.com/doc/qianfan-api/s/3m7of64lb
+
+     Args:
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`None`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`None`)
+        repetition_penalty (float, optional): Penalizes new tokens based on
+            their appearance in the prompt and generated text.
+            (default: :obj:`None`)
+        stream (bool, optional): Whether to stream the response.
+            (default: :obj:`None`)
+        temperature (float, optional): Controls randomness in the response.
+            Higher values make output more random, lower values make it more
+            deterministic. Range: [0.0, 2.0]. (default: :obj:`None`)
+        top_p (float, optional): Controls diversity via nucleus sampling.
+            Range: [0.0, 1.0]. (default: :obj:`None`)
+        logit_bias (dict, optional): Modify the likelihood of specified tokens
+            appearing in the completion. Accepts a json object that maps tokens
+            (specified by their token ID in the tokenizer) to an associated
+            bias value from :obj:`-100` to :obj:`100`. Mathematically, the bias
+            is added to the logits generated by the model prior to sampling.
+            The exact effect will vary per model, but values between:obj:` -1`
+            and :obj:`1` should decrease or increase likelihood of selection;
+            values like :obj:`-100` or :obj:`100` should result in a ban or
+            exclusive selection of the relevant token. (default: :obj:`None`)
+        max_tokens (Union[int, NotGiven], optional): Maximum number of tokens
+            to generate. If not provided, model will use its default maximum.
+            (default: :obj:`None`)
+        stop (Optional[List[str]], optional): List of stop sequences.
+            (default: :obj:`None`)
+        n (Optional[int], optional): Number of chat completion choices to
+            generate for each input message. (default: :obj:`None`)
+        tools (List, optional): Specifies an array of tools that the model can
+            call. It can contain one or more tool objects. During a function
+            call process, the model will select one tool from the array.
+            (default: :obj:`None`)
+    """
+
+    stream: Optional[bool] = Field(default=None)
+    temperature: Optional[float] = Field(default=None)
+    top_p: Optional[float] = Field(default=None)
+    presence_penalty: Optional[float] = Field(default=None)
+    frequency_penalty: Optional[float] = Field(default=None)
+    repetition_penalty: Optional[float] = Field(default=None)
+    max_tokens: Optional[Union[int, NotGiven]] = Field(default=None)
+    stop: Optional[List[str]] = Field(default=None)
+    n: Optional[int] = Field(default=None)
+    logit_bias: Optional[Dict[str, float]] = Field(default=None)
+
+
+QIANFAN_API_PARAMS = {param for param in QianfanConfig.model_fields.keys()}

camel/models/__init__.py

@@ -41,6 +41,7 @@ from .openai_compatible_model import OpenAICompatibleModel
 from .openai_model import OpenAIModel
 from .openrouter_model import OpenRouterModel
 from .ppio_model import PPIOModel
+from .qianfan_model import QianfanModel
 from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
@@ -97,5 +98,6 @@ __all__ = [
     'VolcanoModel',
     'LMStudioModel',
     'WatsonXModel',
+    'QianfanModel',
     'CrynuxModel',
 ]

camel/models/aiml_model.py

@@ -46,6 +46,10 @@ class AIMLModel(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", "AIML_API_KEY")])
@@ -57,6 +61,8 @@ class AIMLModel(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 = AIMLConfig().as_dict()
@@ -73,6 +79,8 @@ class AIMLModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/anthropic_model.py

@@ -46,6 +46,10 @@ class AnthropicModel(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 AnthropicModel(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 = AnthropicConfig().as_dict()
@@ -79,6 +85,8 @@ class AnthropicModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     @property

camel/models/aws_bedrock_model.py

@@ -50,6 +50,10 @@ class AWSBedrockModel(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://docs.aws.amazon.com/bedrock/latest/APIReference/welcome.html
@@ -69,6 +73,8 @@ class AWSBedrockModel(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 = BedrockConfig().as_dict()
@@ -84,6 +90,8 @@ class AWSBedrockModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     async def _arun(

camel/models/azure_openai_model.py

@@ -76,7 +76,10 @@ class AzureOpenAIModel(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.
 
     References:
         https://learn.microsoft.com/en-us/azure/ai-services/openai/
@@ -94,6 +97,8 @@ class AzureOpenAIModel(BaseModelBackend):
         azure_deployment_name: Optional[str] = None,
         azure_ad_token_provider: Optional["AzureADTokenProvider"] = None,
         azure_ad_token: Optional[str] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
@@ -135,7 +140,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
             self._async_client = LangfuseAsyncOpenAI(
                 azure_endpoint=str(self._url),
@@ -145,7 +151,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
         else:
             self._client = AzureOpenAI(
@@ -156,7 +163,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
 
             self._async_client = AsyncAzureOpenAI(
@@ -167,7 +175,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
 
     @property

camel/models/base_model.py

@@ -71,6 +71,8 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
             :obj:`OpenAITokenCounter` will be used. (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`)
     """
 
     def __init__(
@@ -81,6 +83,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
     ) -> None:
         self.model_type: UnifiedModelType = UnifiedModelType(model_type)
         if model_config_dict is None:
@@ -90,6 +93,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self._url = url
         self._token_counter = token_counter
         self._timeout = timeout
+        self._max_retries = max_retries
         self.check_model_config()
 
     @property

camel/models/cohere_model.py

@@ -76,6 +76,8 @@ class CohereModel(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(
@@ -91,6 +93,7 @@ class CohereModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        **kwargs: Any,
     ):
         import cohere
 
@@ -105,10 +108,14 @@ class CohereModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = cohere.ClientV2(
-            timeout=self._timeout, api_key=self._api_key
+            timeout=self._timeout,
+            api_key=self._api_key,
+            **kwargs,
         )
         self._async_client = cohere.AsyncClientV2(
-            timeout=self._timeout, api_key=self._api_key
+            timeout=self._timeout,
+            api_key=self._api_key,
+            **kwargs,
         )
 
     def _to_openai_response(self, response: 'ChatResponse') -> ChatCompletion:

camel/models/crynux_model.py

@@ -46,6 +46,10 @@ class CrynuxModel(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(
@@ -61,6 +65,8 @@ class CrynuxModel(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 = CrynuxConfig().as_dict()
@@ -76,6 +82,8 @@ class CrynuxModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/deepseek_model.py

@@ -78,6 +78,10 @@ class DeepSeekModel(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://api-docs.deepseek.com/
@@ -96,6 +100,8 @@ class DeepSeekModel(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 = DeepSeekConfig().as_dict()
@@ -112,6 +118,8 @@ class DeepSeekModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _prepare_request(

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