camel-ai 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

camel/toolkits/weather_toolkit.py

@@ -15,7 +15,7 @@ import os
 from typing import List, Literal
 
 from camel.toolkits.base import BaseToolkit
-from camel.toolkits.openai_function import OpenAIFunction
+from camel.toolkits.function_tool import FunctionTool
 
 
 class WeatherToolkit(BaseToolkit):
@@ -157,17 +157,17 @@ class WeatherToolkit(BaseToolkit):
             )
             return error_message
 
-    def get_tools(self) -> List[OpenAIFunction]:
-        r"""Returns a list of OpenAIFunction objects representing the
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
         functions in the toolkit.
 
         Returns:
-            List[OpenAIFunction]: A list of OpenAIFunction objects
+            List[FunctionTool]: A list of FunctionTool objects
                 representing the functions in the toolkit.
         """
         return [
-            OpenAIFunction(self.get_weather_data),
+            FunctionTool(self.get_weather_data),
         ]
 
 
-WEATHER_FUNCS: List[OpenAIFunction] = WeatherToolkit().get_tools()
+WEATHER_FUNCS: List[FunctionTool] = WeatherToolkit().get_tools()

camel/toolkits/whatsapp_toolkit.py

@@ -0,0 +1,177 @@
+# =========== 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. ===========
+
+import os
+from typing import Any, Dict, List, Union
+
+import requests
+
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+from camel.utils.commons import retry_request
+
+
+class WhatsAppToolkit(BaseToolkit):
+    r"""A class representing a toolkit for WhatsApp operations.
+
+    This toolkit provides methods to interact with the WhatsApp Business API,
+    allowing users to send messages, retrieve message templates, and get
+    business profile information.
+
+    Attributes:
+        retries (int): Number of retries for API requests in case of failure.
+        delay (int): Delay between retries in seconds.
+        base_url (str): Base URL for the WhatsApp Business API.
+        version (str): API version.
+    """
+
+    def __init__(self, retries: int = 3, delay: int = 1):
+        r"""Initializes the WhatsAppToolkit with the specified number of
+        retries and delay.
+
+        Args:
+            retries (int): Number of times to retry the request in case of
+                failure. (default: :obj:`3`)
+            delay (int): Time in seconds to wait between retries.
+                (default: :obj:`1`)
+        """
+        self.retries = retries
+        self.delay = delay
+        self.base_url = "https://graph.facebook.com"
+        self.version = "v17.0"
+
+        self.access_token = os.environ.get("WHATSAPP_ACCESS_TOKEN", "")
+        self.phone_number_id = os.environ.get("WHATSAPP_PHONE_NUMBER_ID", "")
+
+        if not all([self.access_token, self.phone_number_id]):
+            raise ValueError(
+                "WhatsApp API credentials are not set. "
+                "Please set the WHATSAPP_ACCESS_TOKEN and "
+                "WHATSAPP_PHONE_NUMBER_ID environment variables."
+            )
+
+    def send_message(
+        self, to: str, message: str
+    ) -> Union[Dict[str, Any], str]:
+        r"""Sends a text message to a specified WhatsApp number.
+
+        Args:
+            to (str): The recipient's WhatsApp number in international format.
+            message (str): The text message to send.
+
+        Returns:
+            Union[Dict[str, Any], str]: A dictionary containing
+                the API response if successful, or an error message string if
+                failed.
+        """
+        url = f"{self.base_url}/{self.version}/{self.phone_number_id}/messages"
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+        }
+        data = {
+            "messaging_product": "whatsapp",
+            "to": to,
+            "type": "text",
+            "text": {"body": message},
+        }
+
+        try:
+            response = retry_request(
+                requests.post,
+                retries=self.retries,
+                delay=self.delay,
+                url=url,
+                headers=headers,
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            return f"Failed to send message: {e!s}"
+
+    def get_message_templates(self) -> Union[List[Dict[str, Any]], str]:
+        r"""Retrieves all message templates for the WhatsApp Business account.
+
+        Returns:
+            Union[List[Dict[str, Any]], str]: A list of dictionaries containing
+                template information if successful, or an error message string
+                if failed.
+        """
+        url = (
+            f"{self.base_url}/{self.version}/{self.phone_number_id}"
+            "/message_templates"
+        )
+        headers = {"Authorization": f"Bearer {self.access_token}"}
+
+        try:
+            response = retry_request(
+                requests.get,
+                retries=self.retries,
+                delay=self.delay,
+                url=url,
+                headers=headers,
+            )
+            response.raise_for_status()
+            return response.json().get("data", [])
+        except Exception as e:
+            return f"Failed to retrieve message templates: {e!s}"
+
+    def get_business_profile(self) -> Union[Dict[str, Any], str]:
+        r"""Retrieves the WhatsApp Business profile information.
+
+        Returns:
+            Union[Dict[str, Any], str]: A dictionary containing the business
+                profile information if successful, or an error message string
+                if failed.
+        """
+        url = (
+            f"{self.base_url}/{self.version}/{self.phone_number_id}"
+            "/whatsapp_business_profile"
+        )
+        headers = {"Authorization": f"Bearer {self.access_token}"}
+        params = {
+            "fields": (
+                "about,address,description,email,profile_picture_url,"
+                "websites,vertical"
+            )
+        }
+
+        try:
+            response = retry_request(
+                requests.get,
+                retries=self.retries,
+                delay=self.delay,
+                url=url,
+                headers=headers,
+                params=params,
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            return f"Failed to retrieve business profile: {e!s}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of OpenAIFunction objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[OpenAIFunction]: A list of OpenAIFunction objects for the
+                toolkit methods.
+        """
+        return [
+            FunctionTool(self.send_message),
+            FunctionTool(self.get_message_templates),
+            FunctionTool(self.get_business_profile),
+        ]

camel/types/__init__.py

@@ -28,6 +28,7 @@ from .enums import (
     VoiceType,
 )
 from .openai_types import (
+    NOT_GIVEN,
     ChatCompletion,
     ChatCompletionAssistantMessageParam,
     ChatCompletionChunk,
@@ -38,7 +39,9 @@ from .openai_types import (
     ChatCompletionUserMessageParam,
     Choice,
     CompletionUsage,
+    NotGiven,
 )
+from .unified_model_type import UnifiedModelType
 
 __all__ = [
     'RoleType',
@@ -59,11 +62,13 @@ __all__ = [
     'ChatCompletionAssistantMessageParam',
     'ChatCompletionFunctionMessageParam',
     'CompletionUsage',
-    'OpenAIVideoType',
     'OpenAIImageType',
     'OpenAIVisionDetailType',
     'OpenAPIName',
     'ModelPlatformType',
     'AudioModelType',
     'VoiceType',
+    'UnifiedModelType',
+    'NOT_GIVEN',
+    'NotGiven',
 ]

camel/types/enums.py

@@ -11,8 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import re
 from enum import Enum, EnumMeta
+from typing import cast
+
+from camel.types.unified_model_type import UnifiedModelType
 
 
 class RoleType(Enum):
@@ -23,7 +25,9 @@ class RoleType(Enum):
     DEFAULT = "default"
 
 
-class ModelType(Enum):
+class ModelType(UnifiedModelType, Enum):
+    DEFAULT = "gpt-4o-mini"
+
     GPT_3_5_TURBO = "gpt-3.5-turbo"
     GPT_4 = "gpt-4"
     GPT_4_TURBO = "gpt-4-turbo"
@@ -33,7 +37,6 @@ class ModelType(Enum):
     O1_MINI = "o1-mini"
 
     GLM_4 = "glm-4"
-    GLM_4_OPEN_SOURCE = "glm-4-open-source"
     GLM_4V = 'glm-4v'
     GLM_3_TURBO = "glm-3-turbo"
 
@@ -48,13 +51,6 @@ class ModelType(Enum):
 
     STUB = "stub"
 
-    LLAMA_2 = "llama-2"
-    LLAMA_3 = "llama-3"
-    VICUNA = "vicuna"
-    VICUNA_16K = "vicuna-16k"
-
-    QWEN_2 = "qwen-2"
-
     # Legacy anthropic models
     # NOTE: anthropic legacy models only Claude 2.1 has system prompt support
     CLAUDE_2_1 = "claude-2.1"
@@ -75,19 +71,28 @@ class ModelType(Enum):
     GEMINI_1_5_PRO = "gemini-1.5-pro"
 
     # Mistral AI models
-    MISTRAL_LARGE = "mistral-large-latest"
-    MISTRAL_NEMO = "open-mistral-nemo"
-    MISTRAL_CODESTRAL = "codestral-latest"
+    MISTRAL_3B = "ministral-3b-latest"
     MISTRAL_7B = "open-mistral-7b"
+    MISTRAL_8B = "ministral-8b-latest"
+    MISTRAL_CODESTRAL = "codestral-latest"
+    MISTRAL_CODESTRAL_MAMBA = "open-codestral-mamba"
+    MISTRAL_LARGE = "mistral-large-latest"
     MISTRAL_MIXTRAL_8x7B = "open-mixtral-8x7b"
     MISTRAL_MIXTRAL_8x22B = "open-mixtral-8x22b"
-    MISTRAL_CODESTRAL_MAMBA = "open-codestral-mamba"
+    MISTRAL_NEMO = "open-mistral-nemo"
+    MISTRAL_PIXTRAL_12B = "pixtral-12b-2409"
 
     # Reka models
     REKA_CORE = "reka-core"
     REKA_FLASH = "reka-flash"
     REKA_EDGE = "reka-edge"
 
+    def __str__(self):
+        return self.value
+
+    def __new__(cls, value) -> "ModelType":
+        return cast("ModelType", UnifiedModelType.__new__(cls, value))
+
     @property
     def value_for_tiktoken(self) -> str:
         if self.is_openai:
@@ -95,7 +100,7 @@ class ModelType(Enum):
         return "gpt-4o-mini"
 
     @property
-    def supports_tool_calling(self) -> bool:
+    def support_native_tool_calling(self) -> bool:
         return any([self.is_openai, self.is_gemini, self.is_mistral])
 
     @property
@@ -132,18 +137,6 @@ class ModelType(Enum):
             ModelType.GLM_4V,
         }
 
-    @property
-    def is_open_source(self) -> bool:
-        r"""Returns whether this type of models is open-source."""
-        return self in {
-            ModelType.LLAMA_2,
-            ModelType.LLAMA_3,
-            ModelType.QWEN_2,
-            ModelType.GLM_4_OPEN_SOURCE,
-            ModelType.VICUNA,
-            ModelType.VICUNA_16K,
-        }
-
     @property
     def is_anthropic(self) -> bool:
         r"""Returns whether this type of models is Anthropic-released model.
@@ -186,6 +179,9 @@ class ModelType(Enum):
             ModelType.MISTRAL_MIXTRAL_8x7B,
             ModelType.MISTRAL_MIXTRAL_8x22B,
             ModelType.MISTRAL_CODESTRAL_MAMBA,
+            ModelType.MISTRAL_PIXTRAL_12B,
+            ModelType.MISTRAL_8B,
+            ModelType.MISTRAL_3B,
         }
 
     @property
@@ -206,7 +202,10 @@ class ModelType(Enum):
         Returns:
             bool: Whether this type of models is gemini.
         """
-        return self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}
+        return self in {
+            ModelType.GEMINI_1_5_FLASH,
+            ModelType.GEMINI_1_5_PRO,
+        }
 
     @property
     def is_reka(self) -> bool:
@@ -230,11 +229,7 @@ class ModelType(Enum):
         """
         if self is ModelType.GLM_4V:
             return 1024
-        elif self is ModelType.VICUNA:
-            # reference: https://lmsys.org/blog/2023-03-30-vicuna/
-            return 2048
         elif self in {
-            ModelType.LLAMA_2,
             ModelType.NEMOTRON_4_REWARD,
             ModelType.STUB,
             ModelType.REKA_CORE,
@@ -248,15 +243,12 @@ class ModelType(Enum):
             ModelType.GROQ_LLAMA_3_70B,
             ModelType.GROQ_GEMMA_7B_IT,
             ModelType.GROQ_GEMMA_2_9B_IT,
-            ModelType.LLAMA_3,
             ModelType.GLM_3_TURBO,
             ModelType.GLM_4,
-            ModelType.GLM_4_OPEN_SOURCE,
         }:
             return 8_192
         elif self in {
             ModelType.GPT_3_5_TURBO,
-            ModelType.VICUNA_16K,
         }:
             return 16_384
         elif self in {
@@ -268,7 +260,10 @@ class ModelType(Enum):
             return 32_768
         elif self in {ModelType.MISTRAL_MIXTRAL_8x22B}:
             return 64_000
-        elif self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
+        elif self in {
+            ModelType.CLAUDE_2_0,
+            ModelType.CLAUDE_INSTANT_1_2,
+        }:
             return 100_000
         elif self in {
             ModelType.GPT_4O,
@@ -278,7 +273,9 @@ class ModelType(Enum):
             ModelType.O1_MINI,
             ModelType.MISTRAL_LARGE,
             ModelType.MISTRAL_NEMO,
-            ModelType.QWEN_2,
+            ModelType.MISTRAL_PIXTRAL_12B,
+            ModelType.MISTRAL_8B,
+            ModelType.MISTRAL_3B,
         }:
             return 128_000
         elif self in {
@@ -299,48 +296,14 @@ class ModelType(Enum):
             ModelType.MISTRAL_CODESTRAL_MAMBA,
         }:
             return 256_000
-        elif self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}:
+        elif self in {
+            ModelType.GEMINI_1_5_FLASH,
+            ModelType.GEMINI_1_5_PRO,
+        }:
             return 1_048_576
         else:
             raise ValueError("Unknown model type")
 
-    def validate_model_name(self, model_name: str) -> bool:
-        r"""Checks whether the model type and the model name matches.
-
-        Args:
-            model_name (str): The name of the model, e.g. "vicuna-7b-v1.5".
-
-        Returns:
-            bool: Whether the model type matches the model name.
-        """
-        if self is ModelType.VICUNA:
-            pattern = r'^vicuna-\d+b-v\d+\.\d+$'
-            return bool(re.match(pattern, model_name))
-        elif self is ModelType.VICUNA_16K:
-            pattern = r'^vicuna-\d+b-v\d+\.\d+-16k$'
-            return bool(re.match(pattern, model_name))
-        elif self is ModelType.LLAMA_2:
-            return (
-                self.value in model_name.lower()
-                or "llama2" in model_name.lower()
-            )
-        elif self is ModelType.LLAMA_3:
-            return (
-                self.value in model_name.lower()
-                or "llama3" in model_name.lower()
-            )
-        elif self is ModelType.QWEN_2:
-            return (
-                self.value in model_name.lower()
-                or "qwen2" in model_name.lower()
-            )
-        elif self is ModelType.GLM_4_OPEN_SOURCE:
-            return (
-                'glm-4' in model_name.lower() or "glm4" in model_name.lower()
-            )
-        else:
-            return self.value in model_name.lower()
-
 
 class EmbeddingModelType(Enum):
     TEXT_EMBEDDING_ADA_2 = "text-embedding-ada-002"
@@ -466,21 +429,21 @@ class OpenAPIName(Enum):
 
 
 class ModelPlatformType(Enum):
+    DEFAULT = "openai"
+
     OPENAI = "openai"
     AZURE = "azure"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
-    OPEN_SOURCE = "open-source"
     OLLAMA = "ollama"
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
-    DEFAULT = "default"
     GEMINI = "gemini"
     VLLM = "vllm"
     MISTRAL = "mistral"
     REKA = "reka"
     TOGETHER = "together"
-    OPENAI_COMPATIBILITY_MODEL = "openai-compatibility-model"
+    OPENAI_COMPATIBLE_MODEL = "openai-compatible-model"
     SAMBA = "samba-nova"
 
     @property
@@ -534,15 +497,10 @@ class ModelPlatformType(Enum):
         return self is ModelPlatformType.MISTRAL
 
     @property
-    def is_open_source(self) -> bool:
-        r"""Returns whether this platform is opensource."""
-        return self is ModelPlatformType.OPEN_SOURCE
-
-    @property
-    def is_openai_compatibility_model(self) -> bool:
+    def is_openai_compatible_model(self) -> bool:
         r"""Returns whether this is a platform supporting openai
         compatibility"""
-        return self is ModelPlatformType.OPENAI_COMPATIBILITY_MODEL
+        return self is ModelPlatformType.OPENAI_COMPATIBLE_MODEL
 
     @property
     def is_gemini(self) -> bool:

camel/types/openai_types.py

@@ -31,6 +31,7 @@ from openai.types.chat.chat_completion_user_message_param import (
     ChatCompletionUserMessageParam,
 )
 from openai.types.completion_usage import CompletionUsage
+from openai._types import NOT_GIVEN, NotGiven
 
 Choice = Choice
 ChatCompletion = ChatCompletion
@@ -42,3 +43,5 @@ ChatCompletionUserMessageParam = ChatCompletionUserMessageParam
 ChatCompletionAssistantMessageParam = ChatCompletionAssistantMessageParam
 ChatCompletionFunctionMessageParam = ChatCompletionFunctionMessageParam
 CompletionUsage = CompletionUsage
+NOT_GIVEN = NOT_GIVEN
+NotGiven = NotGiven

camel/types/unified_model_type.py

@@ -0,0 +1,104 @@
+# =========== 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. ===========
+import logging
+from threading import Lock
+from typing import TYPE_CHECKING, ClassVar, Dict, Union, cast
+
+if TYPE_CHECKING:
+    from camel.types import ModelType
+
+
+class UnifiedModelType(str):
+    r"""Class used for support both :obj:`ModelType` and :obj:`str` to be used
+    to represent a model type in a unified way. This class is a subclass of
+    :obj:`str` so that it can be used as string seamlessly.
+
+    Args:
+        value (Union[ModelType, str]): The value of the model type.
+    """
+
+    _cache: ClassVar[Dict[str, "UnifiedModelType"]] = {}
+    _lock: ClassVar[Lock] = Lock()
+
+    def __new__(cls, value: Union["ModelType", str]) -> "UnifiedModelType":
+        with cls._lock:
+            if value not in cls._cache:
+                instance = super().__new__(cls, value)
+                cls._cache[value] = cast(UnifiedModelType, instance)
+            else:
+                instance = cls._cache[value]
+        return instance
+
+    def __init__(self, value: Union["ModelType", str]) -> None:
+        pass
+
+    @property
+    def value_for_tiktoken(self) -> str:
+        r"""Returns the model name for TikToken."""
+        return "gpt-4o-mini"
+
+    @property
+    def token_limit(self) -> int:
+        r"""Returns the token limit for the model. Here we set the default
+        value as `999_999_999` if it's not provided from `model_config_dict`"""
+        logging.warning(
+            "Invalid or missing `max_tokens` in `model_config_dict`. "
+            "Defaulting to 999_999_999 tokens."
+        )
+        return 999_999_999
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether the model is an OpenAI model."""
+        return True
+
+    @property
+    def is_anthropic(self) -> bool:
+        r"""Returns whether the model is an Anthropic model."""
+        return True
+
+    @property
+    def is_azure_openai(self) -> bool:
+        r"""Returns whether the model is an Azure OpenAI model."""
+        return True
+
+    @property
+    def is_groq(self) -> bool:
+        r"""Returns whether the model is a Groq served model."""
+        return True
+
+    @property
+    def is_zhipuai(self) -> bool:
+        r"""Returns whether the model is a Zhipuai model."""
+        return True
+
+    @property
+    def is_gemini(self) -> bool:
+        r"""Returns whether the model is a Gemini model."""
+        return True
+
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether the model is a Mistral model."""
+        return True
+
+    @property
+    def is_reka(self) -> bool:
+        r"""Returns whether the model is a Reka model."""
+        return True
+
+    @property
+    def support_native_tool_calling(self) -> bool:
+        r"""Returns whether the model supports native tool calling."""
+        return False

camel/utils/__init__.py

@@ -43,7 +43,6 @@ from .token_counting import (
     LiteLLMTokenCounter,
     MistralTokenCounter,
     OpenAITokenCounter,
-    OpenSourceTokenCounter,
     get_model_encoding,
 )
 
@@ -60,7 +59,6 @@ __all__ = [
     'get_model_encoding',
     'BaseTokenCounter',
     'OpenAITokenCounter',
-    'OpenSourceTokenCounter',
     'LiteLLMTokenCounter',
     'Constants',
     'text_extract_from_web',

camel/utils/async_func.py

@@ -14,20 +14,20 @@
 import asyncio
 from copy import deepcopy
 
-from camel.toolkits import OpenAIFunction
+from camel.toolkits import FunctionTool
 
 
-def sync_funcs_to_async(funcs: list[OpenAIFunction]) -> list[OpenAIFunction]:
+def sync_funcs_to_async(funcs: list[FunctionTool]) -> list[FunctionTool]:
     r"""Convert a list of Python synchronous functions to Python
     asynchronous functions.
 
     Args:
-        funcs (list[OpenAIFunction]): List of Python synchronous
-            functions in the :obj:`OpenAIFunction` format.
+        funcs (list[FunctionTool]): List of Python synchronous
+            functions in the :obj:`FunctionTool` format.
 
     Returns:
-        list[OpenAIFunction]: List of Python asynchronous functions
-            in the :obj:`OpenAIFunction` format.
+        list[FunctionTool]: List of Python asynchronous functions
+            in the :obj:`FunctionTool` format.
     """
     async_funcs = []
     for func in funcs:
@@ -37,6 +37,6 @@ def sync_funcs_to_async(funcs: list[OpenAIFunction]) -> list[OpenAIFunction]:
             return asyncio.to_thread(sync_func, *args, **kwargs)  # noqa: B023
 
         async_funcs.append(
-            OpenAIFunction(async_callable, deepcopy(func.openai_tool_schema))
+            FunctionTool(async_callable, deepcopy(func.openai_tool_schema))
         )
     return async_funcs