camel-ai 0.2.5__py3-none-any.whl → 0.2.7__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.2.5'
+__version__ = '0.2.7'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -106,6 +106,11 @@ class FunctionCallingRecord(BaseModel):
         )
 
     def as_dict(self) -> dict[str, Any]:
+        r"""Returns the function calling record as a dictionary.
+
+        Returns:
+            dict[str, Any]: The function calling record as a dictionary.
+        """
         return self.model_dump()
 
 
@@ -175,9 +180,6 @@ class ChatAgent(BaseAgent):
                 model_type=ModelType.DEFAULT,
             )
         )
-        self.output_language: Optional[str] = output_language
-        if self.output_language is not None:
-            self.set_output_language(self.output_language)
 
         self.model_type = self.model_backend.model_type
 
@@ -213,12 +215,27 @@ class ChatAgent(BaseAgent):
             context_creator, window_size=message_window_size
         )
 
+        self.output_language: Optional[str] = output_language
+        if self.output_language is not None:
+            self.set_output_language(self.output_language)
+
         self.terminated: bool = False
         self.response_terminators = response_terminators or []
         self.init_messages()
 
+        self.tool_prompt_added = False
+
     # ruff: noqa: E501
     def _generate_tool_prompt(self, tool_schema_list: List[Dict]) -> str:
+        r"""Generates a tool prompt based on the provided tool schema list.
+
+        Args:
+            tool_schema_list (List[Dict]): A list of dictionaries, each
+                containing a tool schema.
+
+        Returns:
+            str: A string representing the tool prompt.
+        """
         tool_prompts = []
 
         for tool in tool_schema_list:
@@ -239,21 +256,36 @@ class ChatAgent(BaseAgent):
 
     {tool_prompt_str}
 
-    If you choose to call a function ONLY reply in the following format with no prefix or suffix:
+    If you choose to call a function ONLY reply in the following format with no
+    prefix or suffix:
 
-    <function=example_function_name>{{"example_name": "example_value"}}</function>
+    <function=example_function_name>{{"example_name": "example_value"}}
+    </function>
 
     Reminder:
-    - Function calls MUST follow the specified format, start with <function= and end with </function>
+    - Function calls MUST follow the specified format, start with <function=
+      and end with </function>
     - Required parameters MUST be specified
     - Only call one function at a time
     - Put the entire function call reply on one line
-    - If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
+    - If there is no function call available, answer the question like normal 
+      with your current knowledge and do not tell the user about function calls
     """
     '''
         return final_prompt
 
     def _parse_tool_response(self, response: str):
+        r"""Parses the tool response to extract the function name and
+        arguments.
+
+        Args:
+            response (str): The response from the model containing the
+                function call.
+
+        Returns:
+            Optional[Dict[str, Any]]: The parsed function name and arguments
+                if found, otherwise :obj:`None`.
+        """
         function_regex = r"<function=(\w+)>(.*?)</function>"
         match = re.search(function_regex, response)
 
@@ -268,12 +300,7 @@ class ChatAgent(BaseAgent):
         return None
 
     def reset(self):
-        r"""Resets the :obj:`ChatAgent` to its initial state and returns the
-        stored messages.
-
-        Returns:
-            List[BaseMessage]: The stored messages.
-        """
+        r"""Resets the :obj:`ChatAgent` to its initial state."""
         self.terminated = False
         self.init_messages()
         for terminator in self.response_terminators:
@@ -290,7 +317,7 @@ class ChatAgent(BaseAgent):
         return self._system_message
 
     @system_message.setter
-    def system_message(self, message: BaseMessage):
+    def system_message(self, message: BaseMessage) -> None:
         r"""The setter method for the property :obj:`system_message`.
 
         Args:
@@ -345,13 +372,19 @@ class ChatAgent(BaseAgent):
             self._system_message = self.orig_sys_message.create_new_instance(
                 content
             )
-            return self._system_message
         else:
             self._system_message = BaseMessage.make_assistant_message(
                 role_name="Assistant",
                 content=language_prompt,
             )
-            return self._system_message
+
+        system_record = MemoryRecord(
+            message=self._system_message,
+            role_at_backend=OpenAIBackendRole.SYSTEM,
+        )
+        self.memory.clear()
+        self.memory.write_record(system_record)
+        return self._system_message
 
     def get_info(
         self,
@@ -448,7 +481,10 @@ class ChatAgent(BaseAgent):
             )
 
         if "llama" in self.model_type.lower():
-            if self.model_backend.model_config_dict.get("tools", None):
+            if (
+                self.model_backend.model_config_dict.get("tools", None)
+                and not self.tool_prompt_added
+            ):
                 tool_prompt = self._generate_tool_prompt(self.tool_schema_list)
 
                 tool_sys_msg = BaseMessage.make_assistant_message(
@@ -457,6 +493,7 @@ class ChatAgent(BaseAgent):
                 )
 
                 self.update_memory(tool_sys_msg, OpenAIBackendRole.SYSTEM)
+                self.tool_prompt_added = True
 
             self.update_memory(input_message, OpenAIBackendRole.USER)
 
@@ -821,6 +858,17 @@ class ChatAgent(BaseAgent):
     ]:
         r"""Internal function of structuring the output of the agent based on
         the given output schema.
+
+        Args:
+            response_format (Type[BaseModel]): The output schema to use for
+                structuring the output.
+
+        Returns:
+            Tuple[List[BaseMessage], List[str], Dict[str, int], str,
+                FunctionCallingRecord, int]:
+                A tuple containing the output messages, finish reasons, usage
+                dictionary, response ID, function calling record, and number of
+                tokens.
         """
         from camel.toolkits import FunctionTool
 
@@ -913,9 +961,39 @@ class ChatAgent(BaseAgent):
         num_tokens: int,
         external_tool_request: Optional[ChatCompletionMessageToolCall] = None,
     ) -> Dict[str, Any]:
-        # Loop over responses terminators, get list of termination
-        # tuples with whether the terminator terminates the agent
-        # and termination reason
+        r"""Process the output of a chat step and gather information about the
+        step.
+
+        This method checks for termination conditions, updates the agent's
+        state, and collects information about the chat step, including tool
+        calls and termination reasons.
+
+        Args:
+            output_messages (List[BaseMessage]): The messages generated in
+                this step.
+            finish_reasons (List[str]): The reasons for finishing the
+                generation for each message.
+            usage_dict (Dict[str, int]): Dictionary containing token usage
+                information.
+            response_id (str): The ID of the response from the model.
+            tool_calls (List[FunctionCallingRecord]): Records of function calls
+                made during this step.
+            num_tokens (int): The number of tokens used in this step.
+            external_tool_request (Optional[ChatCompletionMessageToolCall]):
+                Any external tool request made during this step.
+                (default::obj:`None`)
+
+        Returns:
+            Dict[str, Any]: A dictionary containing information about the chat
+                step, including termination status, reasons, and tool call
+                information.
+
+        Note:
+            This method iterates over all response terminators and checks if
+            any of them signal termination. If a terminator signals
+            termination, the agent's state is updated accordingly, and the
+            termination reason is recorded.
+        """
         termination = [
             terminator.is_terminated(output_messages)
             for terminator in self.response_terminators
@@ -946,7 +1024,8 @@ class ChatAgent(BaseAgent):
     def handle_batch_response(
         self, response: ChatCompletion
     ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
-        r"""
+        r"""Process a batch response from the model and extract the necessary
+        information.
 
         Args:
             response (dict): Model response.
@@ -979,7 +1058,18 @@ class ChatAgent(BaseAgent):
             response.id,
         )
 
-    def _safe_model_dump(self, obj):
+    def _safe_model_dump(self, obj) -> dict:
+        r"""Safely dump a Pydantic model to a dictionary.
+
+        This method attempts to use the `model_dump` method if available,
+        otherwise it falls back to the `dict` method.
+
+        Args:
+            obj: The Pydantic model instance to be dumped.
+
+        Returns:
+            dict: A dictionary representation of the Pydantic model.
+        """
         # Check if the `model_dump` method exists (Pydantic v2)
         if hasattr(obj, 'model_dump'):
             return obj.model_dump()
@@ -994,7 +1084,8 @@ class ChatAgent(BaseAgent):
         response: Stream[ChatCompletionChunk],
         prompt_tokens: int,
     ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
-        r"""
+        r"""Process a stream response from the model and extract the necessary
+        information.
 
         Args:
             response (dict): Model response.

camel/configs/__init__.py

@@ -19,17 +19,17 @@ 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
+from .qwen_config import QWEN_API_PARAMS, QwenConfig
 from .reka_config import REKA_API_PARAMS, RekaConfig
 from .samba_config import (
     SAMBA_CLOUD_API_PARAMS,
-    SAMBA_FAST_API_PARAMS,
     SAMBA_VERSE_API_PARAMS,
     SambaCloudAPIConfig,
-    SambaFastAPIConfig,
     SambaVerseAPIConfig,
 )
 from .togetherai_config import TOGETHERAI_API_PARAMS, TogetherAIConfig
 from .vllm_config import VLLM_API_PARAMS, VLLMConfig
+from .yi_config import YI_API_PARAMS, YiConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
 __all__ = [
@@ -54,12 +54,14 @@ __all__ = [
     'MISTRAL_API_PARAMS',
     'RekaConfig',
     'REKA_API_PARAMS',
-    'SambaFastAPIConfig',
-    'SAMBA_FAST_API_PARAMS',
     'SambaVerseAPIConfig',
     'SAMBA_VERSE_API_PARAMS',
     'SambaCloudAPIConfig',
     'SAMBA_CLOUD_API_PARAMS',
     'TogetherAIConfig',
     'TOGETHERAI_API_PARAMS',
+    'YiConfig',
+    'YI_API_PARAMS',
+    'QwenConfig',
+    'QWEN_API_PARAMS',
 ]

camel/configs/base_config.py

@@ -20,6 +20,12 @@ from pydantic import BaseModel, ConfigDict, field_validator
 
 
 class BaseConfig(ABC, BaseModel):
+    r"""Base configuration class for all models.
+
+    This class provides a common interface for all models, ensuring that all
+    models have a consistent set of attributes and methods.
+    """
+
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
         extra="forbid",
@@ -38,6 +44,12 @@ class BaseConfig(ABC, BaseModel):
     @field_validator("tools", mode="before")
     @classmethod
     def fields_type_checking(cls, tools):
+        r"""Validate the type of tools in the configuration.
+
+        This method ensures that the tools provided in the configuration are
+        instances of `FunctionTool`. If any tool is not an instance of
+        `FunctionTool`, it raises a ValueError.
+        """
         if tools is not None:
             from camel.toolkits import FunctionTool
 
@@ -50,6 +62,15 @@ class BaseConfig(ABC, BaseModel):
         return tools
 
     def as_dict(self) -> dict[str, Any]:
+        r"""Convert the current configuration to a dictionary.
+
+        This method converts the current configuration object to a dictionary
+        representation, which can be used for serialization or other purposes.
+
+        Returns:
+            dict[str, Any]: A dictionary representation of the current
+                configuration.
+        """
         config_dict = self.model_dump()
 
         tools_schema = None

camel/configs/gemini_config.py

@@ -87,6 +87,12 @@ class GeminiConfig(BaseConfig):
     @model_validator(mode="before")
     @classmethod
     def model_type_checking(cls, data: Any):
+        r"""Validate the type of tools in the configuration.
+
+        This method ensures that the tools provided in the configuration are
+        instances of `FunctionTool`. If any tool is not an instance of
+        `FunctionTool`, it raises a ValueError.
+        """
         if isinstance(data, dict):
             response_schema = data.get("response_schema")
             safety_settings = data.get("safety_settings")
@@ -111,16 +117,17 @@ class GeminiConfig(BaseConfig):
 
         if response_schema and not isinstance(response_schema, Schema):
             raise ValueError(
-                "The response_schema should be "
-                "an instance of `google.generativeai.protos.Schema`."
+                "The response_schema should be an instance of "
+                "google.generativeai.protos.Schema."
             )
 
         if safety_settings and not isinstance(
             safety_settings, SafetySettingOptions
         ):
             raise ValueError(
-                "The response_schema should be an instance of "
-                "`google.generativeai.types.safety_types.SafetySettingOptions`."
+                "The safety_settings should be an instance of "
+                "google.generativeai.types.safety_types."
+                "SafetySettingOptions."
             )
 
         if tools is not None:
@@ -128,19 +135,20 @@ class GeminiConfig(BaseConfig):
                 if not isinstance(tool, FunctionLibraryType):
                     raise ValueError(
                         "The tool should be an instance of "
-                        "`google.generativeai.types.content_types.FunctionLibraryType`."
+                        "google.generativeai.types.content_types."
+                        "FunctionLibraryType."
                     )
         if tool_config and not isinstance(tool_config, ToolConfigType):
             raise ValueError(
-                "The response_schema should be an instance of "
-                "`google.generativeai.types.content_types.ToolConfigType`."
+                "The tool_config should be an instance of "
+                "google.generativeai.types.content_types.ToolConfigType."
             )
         if request_options and not isinstance(
             request_options, RequestOptionsType
         ):
             raise ValueError(
-                "The response_schema should be an instance of "
-                "`google.generativeai.types.helper_types.RequestOptionsType`."
+                "The request_options should be an instance of "
+                "google.generativeai.types.helper_types.RequestOptionsType."
             )
         return data
 

camel/configs/qwen_config.py

@@ -0,0 +1,91 @@
+# =========== 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 typing import ClassVar, Optional, Union
+
+from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
+
+
+class QwenConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Qwen API. You can refer to the following link for more details:
+    https://help.aliyun.com/zh/model-studio/developer-reference/use-qwen-by-calling-api
+
+    Args:
+        stream (bool, optional): Whether to stream the response.
+            (default: :obj:`False`)
+        temperature (float, optional): Controls the diversity and focus of
+            the generated results. Lower values make the output more focused,
+            while higher values make it more diverse. (default: :obj:`0.3`)
+        top_p (float, optional): Controls the diversity and focus of the
+            generated results. Higher values make the output more diverse,
+            while lower values make it more focused. (default: :obj:`0.9`)
+        presence_penalty (float, optional): Controls the repetition of
+            content in the generated results. Positive values reduce the
+            repetition of content, while negative values increase it.
+            (default: :obj:`0.0`)
+        response_format (object, optional): Specifies the format of the
+            returned content. The available values are `{"type": "text"}` or
+            `{"type": "json_object"}`. Setting it to `{"type": "json_object"}`
+            will output a standard JSON string.
+            (default: :obj:`{"type": "text"}`)
+        max_tokens (Union[int, NotGiven], optional): Allows the model to
+            generate the maximum number of tokens.
+            (default: :obj:`NOT_GIVEN`)
+        seed (int, optional): Sets the seed parameter to make the text
+            generation process more deterministic, typically used to ensure
+            that the results are consistent across model runs. By passing the
+            same seed value (specified by you) in each model call while
+            keeping other parameters unchanged, the model is likely to return
+            the same result.
+            (default: :obj:`None`)
+        stop (str or list, optional): Using the stop parameter, the model will
+            automatically stop generating text when it is about to include the
+            specified string or token_id. You can use the stop parameter to
+            control the output of the model by passing sensitive words.
+            (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`)
+        extra_body (dict, optional): Additional parameters to be sent to the
+            Qwen API. If you want to enable internet search, you can set this
+            parameter to `{"enable_search": True}`.
+            (default: :obj:`{"enable_search": False}`)
+        include_usage (bool, optional): When streaming, specifies whether to
+            include usage information in `stream_options`. (default:
+            :obj:`True`)
+    """
+
+    stream: bool = False
+    temperature: float = 0.3
+    top_p: float = 0.9
+    presence_penalty: float = 0.0
+    response_format: ClassVar[dict] = {"type": "text"}
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    seed: Optional[int] = None
+    stop: Optional[Union[str, list]] = None
+    extra_body: ClassVar[dict] = {"enable_search": False}
+
+    def __init__(self, include_usage: bool = True, **kwargs):
+        super().__init__(**kwargs)
+        # Only set stream_options when stream is True
+        # Otherwise, it will raise error when calling the API
+        if self.stream:
+            self.stream_options = {"include_usage": include_usage}
+
+
+QWEN_API_PARAMS = {param for param in QwenConfig.model_fields.keys()}

camel/configs/samba_config.py

@@ -13,7 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Sequence, Union
+from typing import Any, Optional, Sequence, Union
 
 from pydantic import Field
 
@@ -21,43 +21,6 @@ from camel.configs.base_config import BaseConfig
 from camel.types import NOT_GIVEN, NotGiven
 
 
-class SambaFastAPIConfig(BaseConfig):
-    r"""Defines the parameters for generating chat completions using the
-    SambaNova Fast API.
-
-    Args:
-        max_tokens (Optional[int], optional): the maximum number of tokens to
-            generate, e.g. 100.
-            (default: :obj:`2048`)
-        stop (Optional[Union[str,list[str]]]): Stop generation if this token
-            is detected. Or if one of these tokens is detected when providing
-            a string list.
-            (default: :obj:`None`)
-        stream (Optional[bool]): If True, partial message deltas will be sent
-            as data-only server-sent events as they become available.
-            Currently SambaNova Fast API only support stream mode.
-            (default: :obj:`True`)
-        stream_options (Optional[Dict]): Additional options for streaming.
-            (default: :obj:`{"include_usage": True}`)
-    """
-
-    max_tokens: Optional[int] = 2048
-    stop: Optional[Union[str, list[str]]] = None
-    stream: Optional[bool] = True
-    stream_options: Optional[Dict] = {"include_usage": True}  # noqa: RUF012
-
-    def as_dict(self) -> dict[str, Any]:
-        config_dict = super().as_dict()
-        if "tools" in config_dict:
-            del config_dict["tools"]  # SambaNova does not support tool calling
-        return config_dict
-
-
-SAMBA_FAST_API_PARAMS = {
-    param for param in SambaFastAPIConfig().model_fields.keys()
-}
-
-
 class SambaVerseAPIConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     SambaVerse API.

camel/configs/yi_config.py

@@ -0,0 +1,58 @@
+# =========== 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 typing import Optional, Union
+
+from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
+
+
+class YiConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Yi API. You can refer to the following link for more details:
+    https://platform.lingyiwanwu.com/docs/api-reference
+
+    Args:
+        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"` or
+            specifying a particular tool via
+            {"type": "function", "function": {"name": "some_function"}}
+            can be used to guide the model to use tools more strongly.
+            (default: :obj:`None`)
+        max_tokens (int, optional): Specifies the maximum number of tokens
+            the model can generate. This sets an upper limit, but does not
+            guarantee that this number will always be reached.
+            (default: :obj:`5000`)
+        top_p (float, optional): Controls the randomness of the generated
+            results. Lower values lead to less randomness, while higher
+            values increase randomness. (default: :obj:`0.9`)
+        temperature (float, optional): Controls the diversity and focus of
+            the generated results. Lower values make the output more focused,
+            while higher values make it more diverse. (default: :obj:`0.3`)
+        stream (bool, optional): If True, enables streaming output.
+            (default: :obj:`False`)
+    """
+
+    tool_choice: Optional[Union[dict[str, str], str]] = None
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    top_p: float = 0.9
+    temperature: float = 0.3
+    stream: bool = False
+
+
+YI_API_PARAMS = {param for param in YiConfig.model_fields.keys()}