camel-ai 0.1.5.5__py3-none-any.whl → 0.1.5.9__py3-none-any.whl

camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.1.5.5'
+__version__ = '0.1.5.9'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -42,8 +42,8 @@ from camel.utils import get_model_encoding
 if TYPE_CHECKING:
     from openai import Stream
 
-    from camel.functions import OpenAIFunction
     from camel.terminators import ResponseTerminator
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)
@@ -82,7 +82,7 @@ class ChatAgent(BaseAgent):
         system_message (BaseMessage): The system message for the chat agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         api_key (str, optional): The API key for authenticating with the
             LLM service. Only OpenAI and Anthropic model supported (default:
             :obj:`None`)
@@ -127,7 +127,7 @@ class ChatAgent(BaseAgent):
             if model is not None
             else ModelFactory.create(
                 model_platform=ModelPlatformType.OPENAI,
-                model_type=ModelType.GPT_3_5_TURBO,
+                model_type=ModelType.GPT_4O_MINI,
                 model_config_dict=ChatGPTConfig().__dict__,
                 api_key=self._api_key,
             )

camel/agents/critic_agent.py

@@ -33,7 +33,7 @@ class CriticAgent(ChatAgent):
             agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         message_window_size (int, optional): The maximum number of previous
             messages to include in the context window. If `None`, no windowing
             is performed. (default: :obj:`6`)

camel/agents/deductive_reasoner_agent.py

@@ -35,7 +35,7 @@ class DeductiveReasonerAgent(ChatAgent):
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
     """
 
     def __init__(
@@ -126,7 +126,7 @@ $B$.
     - Direct Path Analysis: What are the immediate and direct conditions 
     required to move from $A$ to $B$?
     - Intermediate States: Are there states between $A$ and $B$ that must be 
-    transversed or can be used to make the transition smoother or more 
+    traversed or can be used to make the transition smoother or more 
     efficient? If yes, what is the content?
     - Constraints & Limitations: Identify potential barriers or restrictions 
     in moving from $A$ to $B$. These can be external (e.g., environmental 
@@ -244,7 +244,7 @@ square brackets)
         print(f"Message content:\n{msg.content}")
 
         # Extract the conditions from the message
-        condistions_dict = {
+        conditions_dict = {
             f"condition {i}": cdt.replace("<", "")
             .replace(">", "")
             .strip()
@@ -281,7 +281,7 @@ square brackets)
         conditions_and_quality_json: Dict[
             str, Union[List[str], Dict[str, str]]
         ] = {}
-        conditions_and_quality_json["conditions"] = condistions_dict
+        conditions_and_quality_json["conditions"] = conditions_dict
         conditions_and_quality_json["labels"] = labels
         conditions_and_quality_json["evaluate_quality"] = quality
 

camel/agents/embodied_agent.py

@@ -35,7 +35,7 @@ class EmbodiedAgent(ChatAgent):
         system_message (BaseMessage): The system message for the chat agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         message_window_size (int, optional): The maximum number of previous
             messages to include in the context window. If `None`, no windowing
             is performed. (default: :obj:`None`)

camel/agents/knowledge_graph_agent.py

@@ -78,17 +78,16 @@ Expected Output:
 
 Nodes:
 
-Node(id='John', type='Person', properties={'agent_generated'})
-Node(id='XYZ Corporation', type='Organization', properties={'agent_generated'})
-Node(id='New York City', type='Location', properties={'agent_generated'})
+Node(id='John', type='Person')
+Node(id='XYZ Corporation', type='Organization')
+Node(id='New York City', type='Location')
 
 Relationships:
 
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ 
-Corporation', type='Organization'), type='WorksAt', properties=
-{'agent_generated'})
+Corporation', type='Organization'), type='WorksAt')
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', 
-type='Location'), type='ResidesIn', properties={'agent_generated'})
+type='Location'), type='ResidesIn')
 
 ===== TASK =====
 Please extracts nodes and relationships from given content and structures them 
@@ -116,14 +115,14 @@ class KnowledgeGraphAgent(ChatAgent):
         Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         """
         system_message = BaseMessage(
             role_name="Graphify",
             role_type=RoleType.ASSISTANT,
             meta_dict=None,
             content="Your mission is to transform unstructured content "
-            "intostructured graph data. Extract nodes and relationships with "
+            "into structured graph data. Extract nodes and relationships with "
             "precision, and let the connections unfold. Your graphs will "
             "illuminate the hidden connections within the chaos of "
             "information.",
@@ -211,11 +210,10 @@ class KnowledgeGraphAgent(ChatAgent):
         import re
 
         # Regular expressions to extract nodes and relationships
-        node_pattern = r"Node\(id='(.*?)', type='(.*?)', properties=(.*?)\)"
+        node_pattern = r"Node\(id='(.*?)', type='(.*?)'\)"
         rel_pattern = (
             r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), "
-            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)', "
-            r"properties=\{(.*?)\}\)"
+            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)'\)"
         )
 
         nodes = {}
@@ -223,8 +221,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract nodes
         for match in re.finditer(node_pattern, input_string):
-            id, type, properties = match.groups()
-            properties = eval(properties)
+            id, type = match.groups()
+            properties = {'source': 'agent_created'}
             if id not in nodes:
                 node = Node(id, type, properties)
                 if self._validate_node(node):
@@ -232,10 +230,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract relationships
         for match in re.finditer(rel_pattern, input_string):
-            subj_id, subj_type, obj_id, obj_type, rel_type, properties_str = (
-                match.groups()
-            )
-            properties = eval(properties_str)
+            subj_id, subj_type, obj_id, obj_type, rel_type = match.groups()
+            properties = {'source': 'agent_created'}
             if subj_id in nodes and obj_id in nodes:
                 subj = nodes[subj_id]
                 obj = nodes[obj_id]

camel/agents/role_assignment_agent.py

@@ -27,7 +27,7 @@ class RoleAssignmentAgent(ChatAgent):
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
 
     Attributes:
         role_assignment_prompt (TextPrompt): A prompt for the agent to generate

camel/agents/search_agent.py

@@ -26,10 +26,9 @@ class SearchAgent(ChatAgent):
     relevance of an answer.
 
     Args:
-        model_type (ModelType, optional): The type of model to use for the
-            agent. (default: :obj:`ModelType.GPT_3_5_TURBO`)
-        model_config (Any, optional): The configuration for the model.
-            (default: :obj:`None`)
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
     """
 
     def __init__(
@@ -76,7 +75,7 @@ class SearchAgent(ChatAgent):
             result = self.step(user_msg).msg.content
             results += result + "\n"
 
-        # Final summarise
+        # Final summarization
         final_prompt = TextPrompt(
             '''Here are some summarized texts which split from one text. Using
             the information to answer the question. If can't find the answer,

camel/agents/task_agent.py

@@ -32,7 +32,7 @@ class TaskSpecifyAgent(ChatAgent):
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         task_type (TaskType, optional): The type of task for which to generate
             a prompt. (default: :obj:`TaskType.AI_SOCIETY`)
         task_specify_prompt (Union[str, TextPrompt], optional): The prompt for
@@ -100,7 +100,6 @@ class TaskSpecifyAgent(ChatAgent):
 
         if meta_dict is not None:
             task_specify_prompt = task_specify_prompt.format(**meta_dict)
-
         task_msg = BaseMessage.make_user_message(
             role_name="Task Specifier", content=task_specify_prompt
         )
@@ -127,7 +126,7 @@ class TaskPlannerAgent(ChatAgent):
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
     """
@@ -202,7 +201,7 @@ class TaskCreationAgent(ChatAgent):
             perform the task.
         model (BaseModelBackend, optional): The LLM backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
         message_window_size (int, optional): The maximum number of previous
@@ -234,7 +233,7 @@ The result must be a numbered list in the format:
     #. Third Task
 
 You can only give me up to {max_task_num} tasks at a time. \
-Each task shoud be concise, concrete and doable for a {role_name}.
+Each task should be concise, concrete and doable for a {role_name}.
 You should make task plan and not ask me questions.
 If you think no new tasks are needed right now, write "No tasks to add."
 Now start to give me new tasks one by one. No more than three tasks.
@@ -313,7 +312,7 @@ class TaskPrioritizationAgent(ChatAgent):
             perform the task.
         model (BaseModelBackend, optional): The LLM backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
         message_window_size (int, optional): The maximum number of previous

camel/configs/__init__.py

@@ -13,13 +13,20 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
+from .gemini_config import (
+    Gemini_API_PARAMS,
+    GeminiConfig,
+)
+from .groq_config import GROQ_API_PARAMS, GroqConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
+from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import (
     OPENAI_API_PARAMS,
     ChatGPTConfig,
     OpenSourceConfig,
 )
+from .vllm_config import VLLM_API_PARAMS, VLLMConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
 __all__ = [
@@ -28,6 +35,8 @@ __all__ = [
     'OPENAI_API_PARAMS',
     'AnthropicConfig',
     'ANTHROPIC_API_PARAMS',
+    'GROQ_API_PARAMS',
+    'GroqConfig',
     'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
@@ -35,4 +44,10 @@ __all__ = [
     'OLLAMA_API_PARAMS',
     'ZhipuAIConfig',
     'ZHIPUAI_API_PARAMS',
+    'GeminiConfig',
+    'Gemini_API_PARAMS',
+    'VLLMConfig',
+    'VLLM_API_PARAMS',
+    'MistralConfig',
+    'MISTRAL_API_PARAMS',
 ]

camel/configs/gemini_config.py

@@ -0,0 +1,98 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+
+from collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Optional
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    from google.generativeai.protos import Schema
+    from google.generativeai.types.content_types import (
+        FunctionLibraryType,
+        ToolConfigType,
+    )
+    from google.generativeai.types.helper_types import RequestOptionsType
+    from google.generativeai.types.safety_types import SafetySettingOptions
+
+
+@dataclass(frozen=True)
+class GeminiConfig(BaseConfig):
+    r"""A simple dataclass used to configure the generation parameters of
+    `GenerativeModel.generate_content`.
+
+    Args:
+        candidate_count (int, optional): Number of responses to return.
+        stop_sequences (Iterable[str], optional): The set of character
+            sequences (up to 5) that will stop output generation. If specified
+            the API will stop at the first appearance of a stop sequence.
+            The stop sequence will not be included as part of the response.
+        max_output_tokens (int, optional): The maximum number of tokens to
+            include in a candidate. If unset, this will default to
+            output_token_limit specified in the model's specification.
+        temperature (float, optional): Controls the randomness of the output.
+            Note: The default value varies by model, see the
+            `Model.temperature` attribute of the `Model` returned
+            the `genai.get_model` function. Values can range from [0.0,1.0],
+            inclusive. A value closer to 1.0 will produce responses that are
+            more varied and creative, while a value closer to 0.0 will
+            typically result in more straightforward responses from the model.
+        top_p (int, optional): The maximum cumulative probability of tokens to
+            consider when sampling. The model uses combined Top-k and nucleus
+            sampling. Tokens are sorted based on their assigned probabilities
+            so that only the most likely tokens are considered. Top-k sampling
+            directly limits the maximum number of tokens to consider, while
+            Nucleus sampling limits number of tokens
+            based on the cumulative probability. Note: The default value varies
+            by model, see the `Model.top_p` attribute of the `Model` returned
+            the `genai.get_model` function.
+        top_k (int, optional): The maximum number of tokens to consider when
+            sampling. The model uses combined Top-k and nucleus sampling.Top-k
+            sampling considers the set of `top_k` most probable tokens.
+            Defaults to 40. Note: The default value varies by model, see the
+            `Model.top_k` attribute of the `Model` returned the
+            `genai.get_model` function.
+        response_mime_type (str, optional): Output response mimetype of the
+            generated candidate text. Supported mimetype:
+            `text/plain`: (default) Text output.
+            `application/json`: JSON response in the candidates.
+        response_schema (Schema, optional): Specifies the format of the
+            JSON requested if response_mime_type is `application/json`.
+        safety_settings (SafetySettingOptions, optional):
+            Overrides for the model's safety settings.
+        tools (FunctionLibraryType, optional):
+            `protos.Tools` more info coming soon.
+        tool_config (ToolConfigType, optional):
+            more info coming soon.
+        request_options (RequestOptionsType, optional):
+            Options for the request.
+    """
+
+    candidate_count: Optional[int] = None
+    stop_sequences: Optional[Iterable[str]] = None
+    max_output_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    response_mime_type: Optional[str] = None
+    response_schema: Optional['Schema'] = None
+    safety_settings: Optional['SafetySettingOptions'] = None
+    tools: Optional['FunctionLibraryType'] = None
+    tool_config: Optional['ToolConfigType'] = None
+    request_options: Optional['RequestOptionsType'] = None
+
+
+Gemini_API_PARAMS = {param for param in asdict(GeminiConfig()).keys()}

camel/configs/groq_config.py

@@ -0,0 +1,119 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Optional, Sequence
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    from camel.toolkits import OpenAIFunction
+
+
+@dataclass(frozen=True)
+class GroqConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility.
+
+    Reference: https://console.groq.com/docs/openai
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`1`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        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:`0.0`)
+        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:`0.0`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`""`)
+        tools (list[OpenAIFunction], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: float = 0.2  # openai default: 1.0
+    top_p: float = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
+    presence_penalty: float = 0.0
+    response_format: dict | NotGiven = NOT_GIVEN
+    frequency_penalty: float = 0.0
+    user: str = ""
+    tools: Optional[list[OpenAIFunction]] = None
+    tool_choice: Optional[dict[str, str] | str] = "none"
+
+    def __post_init__(self):
+        if self.tools is not None:
+            object.__setattr__(
+                self,
+                'tools',
+                [tool.get_openai_tool_schema() for tool in self.tools],
+            )
+
+
+GROQ_API_PARAMS = {param for param in asdict(GroqConfig()).keys()}

camel/configs/litellm_config.py

@@ -19,7 +19,7 @@ from typing import TYPE_CHECKING, List, Optional, Union
 from camel.configs.base_config import BaseConfig
 
 if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)

camel/configs/mistral_config.py

@@ -0,0 +1,81 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Dict, Optional, Union
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    from mistralai.models.chat_completion import (
+        ResponseFormat,
+    )
+
+    from camel.toolkits import OpenAIFunction
+
+
+@dataclass(frozen=True)
+class MistralConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Mistral API.
+
+    reference: https://github.com/mistralai/client-python/blob/9d238f88c41689821d7b08570f13b43426f97fd6/src/mistralai/client.py#L195
+
+    Args:
+        temperature (Optional[float], optional): temperature the temperature
+            to use for sampling, e.g. 0.5.
+        max_tokens (Optional[int], optional): the maximum number of tokens to
+            generate, e.g. 100. Defaults to None.
+        top_p (Optional[float], optional): the cumulative probability of
+            tokens to generate, e.g. 0.9. Defaults to None.
+        random_seed (Optional[int], optional): the random seed to use for
+            sampling, e.g. 42. Defaults to None.
+        safe_mode (bool, optional): deprecated, use safe_prompt instead.
+            Defaults to False.
+        safe_prompt (bool, optional): whether to use safe prompt, e.g. true.
+            Defaults to False.
+        response_format (Union[Dict[str, str], ResponseFormat): format of the
+            response.
+        tools (Optional[list[OpenAIFunction]], optional): a list of tools to
+            use.
+        tool_choice (str, optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"any"` means the
+            model must call one or more tools. :obj:`"auto"` is the default
+            value.
+    """
+
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    random_seed: Optional[int] = None
+    safe_mode: bool = False
+    safe_prompt: bool = False
+    response_format: Optional[Union[Dict[str, str], ResponseFormat]] = None
+    tools: Optional[list[OpenAIFunction]] = None
+    tool_choice: Optional[str] = "auto"
+
+    def __post_init__(self):
+        if self.tools is not None:
+            object.__setattr__(
+                self,
+                'tools',
+                [tool.get_openai_tool_schema() for tool in self.tools],
+            )
+
+
+MISTRAL_API_PARAMS = {param for param in asdict(MistralConfig()).keys()}

camel/configs/ollama_config.py

@@ -24,7 +24,7 @@ from camel.configs.base_config import BaseConfig
 @dataclass(frozen=True)
 class OllamaConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using OpenAI
-    compatibility
+    compatibility.
 
     Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
 

camel/configs/openai_config.py

@@ -21,7 +21,7 @@ from openai._types import NOT_GIVEN, NotGiven
 from camel.configs.base_config import BaseConfig
 
 if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)