camel-ai 0.2.11__py3-none-any.whl → 0.2.12__py3-none-any.whl

camel/toolkits/search_toolkit.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
 import xml.etree.ElementTree as ET
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, TypeAlias, Union
 
 import requests
 
@@ -26,7 +26,7 @@ class SearchToolkit(BaseToolkit):
     r"""A class representing a toolkit for web search.
 
     This class provides methods for searching information on the web using
-    search engines like Google, DuckDuckGo, Wikipedia and Wolfram Alpha.
+    search engines like Google, DuckDuckGo, Wikipedia and Wolfram Alpha, Brave.
     """
 
     @dependencies_required("wikipedia")
@@ -151,6 +151,152 @@ class SearchToolkit(BaseToolkit):
         # If no answer found, return an empty list
         return responses
 
+    @api_keys_required("BRAVE_API_KEY")
+    def search_brave(
+        self,
+        q: str,
+        country: str = "US",
+        search_lang: str = "en",
+        ui_lang: str = "en-US",
+        count: int = 20,
+        offset: int = 0,
+        safesearch: str = "moderate",
+        freshness: Optional[str] = None,
+        text_decorations: bool = True,
+        spellcheck: bool = True,
+        result_filter: Optional[str] = None,
+        goggles_id: Optional[str] = None,
+        units: Optional[str] = None,
+        extra_snippets: Optional[bool] = None,
+        summary: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        r"""This function queries the Brave search engine API and returns a
+        dictionary, representing a search result.
+        See https://api.search.brave.com/app/documentation/web-search/query
+        for more details.
+
+        Args:
+            q (str): The user's search query term. Query cannot be empty.
+                Maximum of 400 characters and 50 words in the query.
+            country (str): The search query country where results come from.
+                The country string is limited to 2 character country codes of
+                supported countries. For a list of supported values, see
+                Country Codes. (default::obj:`US `)
+            search_lang (str): The search language preference. The 2 or more
+                character language code for which search results are provided.
+                For a list of possible values, see Language Codes.
+            ui_lang (str): User interface language preferred in response.
+                Usually of the format '<language_code>-<country_code>'. For
+                more, see RFC 9110. For a list of supported values, see UI
+                Language Codes.
+            count (int): The number of search results returned in response.
+                The maximum is 20. The actual number delivered may be less than
+                requested. Combine this parameter with offset to paginate
+                search results.
+            offset (int): The zero based offset that indicates number of search
+                results per page (count) to skip before returning the result.
+                The maximum is 9. The actual number delivered may be less than
+                requested based on the query. In order to paginate results use
+                this parameter together with count. For example, if your user
+                interface displays 20 search results per page, set count to 20
+                and offset to 0 to show the first page of results. To get
+                subsequent pages, increment offset by 1 (e.g. 0, 1, 2). The
+                results may overlap across multiple pages.
+            safesearch (str): Filters search results for adult content.
+                The following values are supported:
+                - 'off': No filtering is done.
+                - 'moderate': Filters explicit content, like images and videos,
+                    but allows adult domains in the search results.
+                - 'strict': Drops all adult content from search results.
+            freshness (Optional[str]): Filters search results by when they were
+                discovered:
+                - 'pd': Discovered within the last 24 hours.
+                - 'pw': Discovered within the last 7 Days.
+                - 'pm': Discovered within the last 31 Days.
+                - 'py': Discovered within the last 365 Days.
+                - 'YYYY-MM-DDtoYYYY-MM-DD': Timeframe is also supported by
+                    specifying the date range e.g. '2022-04-01to2022-07-30'.
+            text_decorations (bool): Whether display strings (e.g. result
+                snippets) should include decoration markers (e.g. highlighting
+                characters).
+            spellcheck (bool): Whether to spellcheck provided query. If the
+                spellchecker is enabled, the modified query is always used for
+                search. The modified query can be found in altered key from the
+                query response model.
+            result_filter (Optional[str]): A comma delimited string of result
+                types to include in the search response. Not specifying this
+                parameter will return back all result types in search response
+                where data is available and a plan with the corresponding
+                option is subscribed. The response always includes query and
+                type to identify any query modifications and response type
+                respectively. Available result filter values are:
+                - 'discussions'
+                - 'faq'
+                - 'infobox'
+                - 'news'
+                - 'query'
+                - 'summarizer'
+                - 'videos'
+                - 'web'
+                - 'locations'
+            goggles_id (Optional[str]): Goggles act as a custom re-ranking on
+                top of Brave's search index. For more details, refer to the
+                Goggles repository.
+            units (Optional[str]): The measurement units. If not provided,
+                units are derived from search country. Possible values are:
+                - 'metric': The standardized measurement system
+                - 'imperial': The British Imperial system of units.
+            extra_snippets (Optional[bool]): A snippet is an excerpt from a
+                page you get as a result of the query, and extra_snippets
+                allow you to get up to 5 additional, alternative excerpts. Only
+                available under Free AI, Base AI, Pro AI, Base Data, Pro Data
+                and Custom plans.
+            summary (Optional[bool]): This parameter enables summary key
+                generation in web search results. This is required for
+                summarizer to be enabled.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing a search result.
+        """
+
+        import requests
+
+        BRAVE_API_KEY = os.getenv("BRAVE_API_KEY")
+
+        url = "https://api.search.brave.com/res/v1/web/search"
+        headers = {
+            "Content-Type": "application/json",
+            "X-BCP-APIV": "1.0",
+            "X-Subscription-Token": BRAVE_API_KEY,
+        }
+
+        ParamsType: TypeAlias = Dict[
+            str,
+            Union[str, int, float, List[Union[str, int, float]], None],
+        ]
+
+        params: ParamsType = {
+            "q": q,
+            "country": country,
+            "search_lang": search_lang,
+            "ui_lang": ui_lang,
+            "count": count,
+            "offset": offset,
+            "safesearch": safesearch,
+            "freshness": freshness,
+            "text_decorations": text_decorations,
+            "spellcheck": spellcheck,
+            "result_filter": result_filter,
+            "goggles_id": goggles_id,
+            "units": units,
+            "extra_snippets": extra_snippets,
+            "summary": summary,
+        }
+
+        response = requests.get(url, headers=headers, params=params)
+        data = response.json()["web"]
+        return data
+
     @api_keys_required("GOOGLE_API_KEY", "SEARCH_ENGINE_ID")
     def search_google(
         self, query: str, num_result_pages: int = 5
@@ -219,6 +365,11 @@ class SearchToolkit(BaseToolkit):
 
                 # Iterate over 10 results found
                 for i, search_item in enumerate(search_items, start=1):
+                    # Check metatags are present
+                    if "pagemap" not in search_item:
+                        continue
+                    if "metatags" not in search_item["pagemap"]:
+                        continue
                     if (
                         "og:description"
                         in search_item["pagemap"]["metatags"][0]
@@ -471,4 +622,5 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.search_duckduckgo),
             FunctionTool(self.query_wolfram_alpha),
             FunctionTool(self.tavily_search),
+            FunctionTool(self.search_brave),
         ]

camel/toolkits/stripe_toolkit.py

@@ -0,0 +1,273 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import json
+import logging
+import os
+from typing import List
+
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+from camel.utils import api_keys_required
+
+
+class StripeToolkit(BaseToolkit):
+    r"""A class representing a toolkit for Stripe operations.
+
+    This toolkit provides methods to interact with the Stripe API,
+    allowing users to operate stripe core resources, including Customer,
+    Balance, BalanceTransaction, Payment, Refund
+
+    Use the Developers Dashboard https://dashboard.stripe.com/test/apikeys to
+    create an API keys as STRIPE_API_KEY.
+
+    Attributes:
+        logger (Logger): a logger to write logs.
+    """
+
+    @api_keys_required("STRIPE_API_KEY")
+    def __init__(self, retries: int = 3):
+        r"""Initializes the StripeToolkit with the specified number of
+        retries.
+
+        Args:
+            retries (int,optional): Number of times to retry the request in
+                case of failure. (default: :obj:`3`)
+        """
+        import stripe
+
+        stripe.max_network_retries = retries
+        stripe.log = 'info'
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        if not self.logger.handlers:
+            self.logger.addHandler(handler)
+        stripe.api_key = os.environ.get("STRIPE_API_KEY")
+
+    def customer_get(self, customer_id: str) -> str:
+        r"""Retrieve a customer by ID.
+
+        Args:
+            customer_id (str): The ID of the customer to retrieve.
+
+        Returns:
+            str: The customer data as a str.
+        """
+        import stripe
+
+        try:
+            self.logger.info(f"Retrieving customer with ID: {customer_id}")
+            customer = stripe.Customer.retrieve(customer_id)
+            self.logger.info(f"Retrieved customer: {customer.id}")
+            json_string = json.dumps(customer)
+            return json_string
+        except Exception as e:
+            return self.handle_exception("customer_get", e)
+
+    def customer_list(self, limit: int = 100) -> str:
+        r"""List customers.
+
+        Args:
+            limit (int, optional): Number of customers to retrieve. (default:
+                :obj:`100`)
+
+        Returns:
+            str: An output str if successful, or an error message string if
+                failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info(f"Listing customers with limit={limit}")
+            customers = stripe.Customer.list(limit=limit).data
+            self.logger.info(
+                f"Successfully retrieved {len(customers)} customers."
+            )
+            return json.dumps([customer for customer in customers])
+        except Exception as e:
+            return self.handle_exception("customer_list", e)
+
+    def balance_get(self) -> str:
+        r"""Retrieve your account balance.
+
+        Returns:
+            str: A str containing the account balance if successful, or an
+                error message string if failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info("Retrieving account balance.")
+            balance = stripe.Balance.retrieve()
+            self.logger.info(
+                f"Successfully retrieved account balance: {balance}."
+            )
+            return json.dumps(balance)
+        except Exception as e:
+            return self.handle_exception("balance_get", e)
+
+    def balance_transaction_list(self, limit: int = 100) -> str:
+        r"""List your balance transactions.
+
+        Args:
+            limit (int, optional): Number of balance transactions to retrieve.
+                (default::obj:`100`)
+
+        Returns:
+            str: A list of balance transaction data if successful, or an error
+                message string if failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info(
+                f"Listing balance transactions with limit={limit}"
+            )
+            transactions = stripe.BalanceTransaction.list(limit=limit).data
+            self.logger.info(
+                f"Successfully retrieved {len(transactions)} "
+                "balance transactions."
+            )
+            return json.dumps([transaction for transaction in transactions])
+        except Exception as e:
+            return self.handle_exception("balance_transaction_list", e)
+
+    def payment_get(self, payment_id: str) -> str:
+        r"""Retrieve a payment by ID.
+
+        Args:
+            payment_id (str): The ID of the payment to retrieve.
+
+        Returns:
+            str:The payment data as a str if successful, or an error message
+                string if failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info(f"Retrieving payment with ID: {payment_id}")
+            payment = stripe.PaymentIntent.retrieve(payment_id)
+            self.logger.info(f"Retrieved payment: {payment.id}")
+            return json.dumps(payment)
+        except Exception as e:
+            return self.handle_exception("payment_get", e)
+
+    def payment_list(self, limit: int = 100) -> str:
+        r"""List payments.
+
+        Args:
+            limit (int, optional): Number of payments to retrieve.
+                (default::obj:`100`)
+
+        Returns:
+            str: A list of payment data if successful, or an error message
+                string if failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info(f"Listing payments with limit={limit}")
+            payments = stripe.PaymentIntent.list(limit=limit).data
+            self.logger.info(
+                f"Successfully retrieved {len(payments)} payments."
+            )
+            return json.dumps([payment for payment in payments])
+        except Exception as e:
+            return self.handle_exception("payment_list", e)
+
+    def refund_get(self, refund_id: str) -> str:
+        r"""Retrieve a refund by ID.
+
+        Args:
+            refund_id (str): The ID of the refund to retrieve.
+
+        Returns:
+            str: The refund data as a str if successful, or an error message
+                string if failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info(f"Retrieving refund with ID: {refund_id}")
+            refund = stripe.Refund.retrieve(refund_id)
+            self.logger.info(f"Retrieved refund: {refund.id}")
+            return json.dumps(refund)
+        except Exception as e:
+            return self.handle_exception("refund_get", e)
+
+    def refund_list(self, limit: int = 100) -> str:
+        r"""List refunds.
+
+        Args:
+            limit (int, optional): Number of refunds to retrieve.
+                (default::obj:`100`)
+
+        Returns:
+            str: A list of refund data as a str if successful, or an error
+                message string if failed.
+        """
+        import stripe
+
+        try:
+            self.logger.info(f"Listing refunds with limit={limit}")
+            refunds = stripe.Refund.list(limit=limit).data
+            self.logger.info(f"Successfully retrieved {len(refunds)} refunds.")
+            return json.dumps([refund for refund in refunds])
+        except Exception as e:
+            return self.handle_exception("refund_list", e)
+
+    def handle_exception(self, func_name: str, error: Exception) -> str:
+        r"""Handle exceptions by logging and returning an error message.
+
+        Args:
+            func_name (str): The name of the function where the exception
+                occurred.
+            error (Exception): The exception instance.
+
+        Returns:
+            str: An error message string.
+        """
+        from stripe import StripeError
+
+        if isinstance(error, StripeError):
+            message = error.user_message or str(error)
+            self.logger.error(f"Stripe error in {func_name}: {message}")
+            return f"Stripe error in {func_name}: {message}"
+        else:
+            self.logger.error(f"Unexpected error in {func_name}: {error!s}")
+            return f"Unexpected error in {func_name}: {error!s}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects for the
+                toolkit methods.
+        """
+        return [
+            FunctionTool(self.customer_get),
+            FunctionTool(self.customer_list),
+            FunctionTool(self.balance_get),
+            FunctionTool(self.balance_transaction_list),
+            FunctionTool(self.payment_get),
+            FunctionTool(self.payment_list),
+            FunctionTool(self.refund_get),
+            FunctionTool(self.refund_list),
+        ]

camel/types/__init__.py

@@ -14,6 +14,7 @@
 from .enums import (
     AudioModelType,
     EmbeddingModelType,
+    HuggingFaceRepoType,
     ModelPlatformType,
     ModelType,
     OpenAIBackendRole,
@@ -73,4 +74,5 @@ __all__ = [
     'NOT_GIVEN',
     'NotGiven',
     'ParsedChatCompletion',
+    'HuggingFaceRepoType',
 ]

camel/types/enums.py

@@ -41,9 +41,12 @@ class ModelType(UnifiedModelType, Enum):
     GLM_4V = 'glm-4v'
     GLM_3_TURBO = "glm-3-turbo"
 
+    # Groq platform models
     GROQ_LLAMA_3_1_8B = "llama-3.1-8b-instant"
     GROQ_LLAMA_3_1_70B = "llama-3.1-70b-versatile"
     GROQ_LLAMA_3_1_405B = "llama-3.1-405b-reasoning"
+    GROQ_LLAMA_3_3_70B = "llama-3.3-70b-versatile"
+    GROQ_LLAMA_3_3_70B_PREVIEW = "llama-3.3-70b-specdec"
     GROQ_LLAMA_3_8B = "llama3-8b-8192"
     GROQ_LLAMA_3_70B = "llama3-70b-8192"
     GROQ_MIXTRAL_8_7B = "mixtral-8x7b-32768"
@@ -59,10 +62,11 @@ class ModelType(UnifiedModelType, Enum):
     CLAUDE_INSTANT_1_2 = "claude-instant-1.2"
 
     # Claude3 models
-    CLAUDE_3_OPUS = "claude-3-opus-20240229"
+    CLAUDE_3_OPUS = "claude-3-opus-latest"
     CLAUDE_3_SONNET = "claude-3-sonnet-20240229"
     CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
-    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20240620"
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-latest"
+    CLAUDE_3_5_HAIKU = "claude-3-5-haiku-latest"
 
     # Nvidia models
     NVIDIA_NEMOTRON_340B_INSTRUCT = "nvidia/nemotron-4-340b-instruct"
@@ -76,6 +80,7 @@ class ModelType(UnifiedModelType, Enum):
     NVIDIA_LLAMA3_1_405B_INSTRUCT = "meta/llama-3.1-405b-instruct"
     NVIDIA_LLAMA3_2_1B_INSTRUCT = "meta/llama-3.2-1b-instruct"
     NVIDIA_LLAMA3_2_3B_INSTRUCT = "meta/llama-3.2-3b-instruct"
+    NVIDIA_LLAMA3_3_70B_INSTRUCT = "meta/llama-3.3-70b-instruct"
 
     # Gemini models
     GEMINI_1_5_FLASH = "gemini-1.5-flash"
@@ -202,6 +207,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.CLAUDE_3_SONNET,
             ModelType.CLAUDE_3_HAIKU,
             ModelType.CLAUDE_3_5_SONNET,
+            ModelType.CLAUDE_3_5_HAIKU,
         }
 
     @property
@@ -211,6 +217,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GROQ_LLAMA_3_1_8B,
             ModelType.GROQ_LLAMA_3_1_70B,
             ModelType.GROQ_LLAMA_3_1_405B,
+            ModelType.GROQ_LLAMA_3_3_70B,
+            ModelType.GROQ_LLAMA_3_3_70B_PREVIEW,
             ModelType.GROQ_LLAMA_3_8B,
             ModelType.GROQ_LLAMA_3_70B,
             ModelType.GROQ_MIXTRAL_8_7B,
@@ -249,6 +257,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NVIDIA_LLAMA3_1_405B_INSTRUCT,
             ModelType.NVIDIA_LLAMA3_2_1B_INSTRUCT,
             ModelType.NVIDIA_LLAMA3_2_3B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_3_70B_INSTRUCT,
         }
 
     @property
@@ -362,6 +371,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GPT_4,
             ModelType.GROQ_LLAMA_3_8B,
             ModelType.GROQ_LLAMA_3_70B,
+            ModelType.GROQ_LLAMA_3_3_70B_PREVIEW,
             ModelType.GROQ_GEMMA_7B_IT,
             ModelType.GROQ_GEMMA_2_9B_IT,
             ModelType.GLM_3_TURBO,
@@ -428,6 +438,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NVIDIA_LLAMA3_1_405B_INSTRUCT,
             ModelType.NVIDIA_LLAMA3_2_1B_INSTRUCT,
             ModelType.NVIDIA_LLAMA3_2_3B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_3_70B_INSTRUCT,
+            ModelType.GROQ_LLAMA_3_3_70B,
         }:
             return 128_000
         elif self in {
@@ -445,6 +457,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.CLAUDE_3_SONNET,
             ModelType.CLAUDE_3_HAIKU,
             ModelType.CLAUDE_3_5_SONNET,
+            ModelType.CLAUDE_3_5_HAIKU,
             ModelType.YI_MEDIUM_200K,
         }:
             return 200_000
@@ -611,6 +624,7 @@ class ModelPlatformType(Enum):
     QWEN = "tongyi-qianwen"
     NVIDIA = "nvidia"
     DEEPSEEK = "deepseek"
+    SGLANG = "sglang"
 
     @property
     def is_openai(self) -> bool:
@@ -642,6 +656,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is vllm."""
         return self is ModelPlatformType.VLLM
 
+    @property
+    def is_sglang(self) -> bool:
+        r"""Returns whether this platform is sglang."""
+        return self is ModelPlatformType.SGLANG
+
     @property
     def is_together(self) -> bool:
         r"""Returns whether this platform is together."""
@@ -749,3 +768,9 @@ class JinaReturnFormat(Enum):
     MARKDOWN = "markdown"
     HTML = "html"
     TEXT = "text"
+
+
+class HuggingFaceRepoType(str, Enum):
+    DATASET = "dataset"
+    MODEL = "model"
+    SPACE = "space"

camel/utils/token_counting.py

@@ -222,13 +222,18 @@ class OpenAITokenCounter(BaseTokenCounter):
 
 class AnthropicTokenCounter(BaseTokenCounter):
     @dependencies_required('anthropic')
-    def __init__(self):
-        r"""Constructor for the token counter for Anthropic models."""
+    def __init__(self, model: str):
+        r"""Constructor for the token counter for Anthropic models.
+
+        Args:
+            model (str): The name of the Anthropic model being used.
+        """
         from anthropic import Anthropic
 
         self.client = Anthropic()
-        self.tokenizer = self.client.get_tokenizer()
+        self.model = model
 
+    @dependencies_required('anthropic')
     def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
         r"""Count number of tokens in the provided message list using
         loaded tokenizer specific for this type of model.
@@ -240,11 +245,18 @@ class AnthropicTokenCounter(BaseTokenCounter):
         Returns:
             int: Number of tokens in the messages.
         """
-        num_tokens = 0
-        for message in messages:
-            content = str(message["content"])
-            num_tokens += self.client.count_tokens(content)
-        return num_tokens
+        from anthropic.types.beta import BetaMessageParam
+
+        return self.client.beta.messages.count_tokens(
+            messages=[
+                BetaMessageParam(
+                    content=str(msg["content"]),
+                    role="user" if msg["role"] == "user" else "assistant",
+                )
+                for msg in messages
+            ],
+            model=self.model,
+        ).input_tokens
 
 
 class GeminiTokenCounter(BaseTokenCounter):
@@ -360,7 +372,7 @@ class MistralTokenCounter(BaseTokenCounter):
                 ModelType.MISTRAL_CODESTRAL,
                 ModelType.MISTRAL_CODESTRAL_MAMBA,
             }
-            else self.model_type.value
+            else self.model_type
         )
 
         self.tokenizer = MistralTokenizer.from_model(model_name)
@@ -403,7 +415,7 @@ class MistralTokenCounter(BaseTokenCounter):
         )
 
         mistral_request = ChatCompletionRequest(  # type: ignore[type-var]
-            model=self.model_type.value,
+            model=self.model_type,
             messages=[openai_msg],
         )