camel-ai 0.2.15a0__py3-none-any.whl → 0.2.17__py3-none-any.whl

camel/toolkits/search_toolkit.py

@@ -13,9 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
 import xml.etree.ElementTree as ET
-from typing import Any, Dict, List, Optional, TypeAlias, Union
+from typing import Any, Dict, List, Literal, Optional, Type, TypeAlias, Union
 
 import requests
+from pydantic import BaseModel
 
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
@@ -63,6 +64,82 @@ class SearchToolkit(BaseToolkit):
 
         return result
 
+    @dependencies_required("linkup")
+    @api_keys_required(
+        [
+            (None, "LINKUP_API_KEY"),
+        ]
+    )
+    def search_linkup(
+        self,
+        query: str,
+        depth: Literal["standard", "deep"] = "standard",
+        output_type: Literal[
+            "searchResults", "sourcedAnswer", "structured"
+        ] = "searchResults",
+        structured_output_schema: Union[Type[BaseModel], str, None] = None,
+    ) -> Dict[str, Any]:
+        r"""Search for a query in the Linkup API and return results in various
+        formats.
+
+        Args:
+            query (str): The search query.
+            depth (Literal["standard", "deep"]): The depth of the search.
+                "standard" for a straightforward search, "deep" for a more
+                comprehensive search.
+            output_type (Literal["searchResults", "sourcedAnswer",
+                "structured"]): The type of output:
+                - "searchResults" for raw search results,
+                - "sourcedAnswer" for an answer with supporting sources,
+                - "structured" for output based on a provided schema.
+            structured_output_schema (Union[Type[BaseModel], str, None]): If
+                `output_type` is "structured",specify the schema of the
+                output. Can be a Pydantic BaseModel or a JSON schema string.
+
+        Returns:
+            Dict[str, Any]: A dictionary representing the search result. The
+                structure depends on the `output_type`. If an error occurs,
+                returns an error message.
+        """
+        try:
+            from linkup import LinkupClient
+
+            # Initialize the Linkup client with the API key
+            LINKUP_API_KEY = os.getenv("LINKUP_API_KEY")
+            client = LinkupClient(api_key=LINKUP_API_KEY)
+
+            # Perform the search using the specified output_type
+            response = client.search(
+                query=query,
+                depth=depth,
+                output_type=output_type,
+                structured_output_schema=structured_output_schema,
+            )
+
+            if output_type == "searchResults":
+                results = [
+                    item.__dict__
+                    for item in response.__dict__.get('results', [])
+                ]
+                return {"results": results}
+
+            elif output_type == "sourcedAnswer":
+                answer = response.__dict__.get('answer', '')
+                sources = [
+                    item.__dict__
+                    for item in response.__dict__.get('sources', [])
+                ]
+                return {"answer": answer, "sources": sources}
+
+            elif output_type == "structured" and structured_output_schema:
+                return response.__dict__
+
+            else:
+                return {"error": f"Invalid output_type: {output_type}"}
+
+        except Exception as e:
+            return {"error": f"An unexpected error occurred: {e!s}"}
+
     @dependencies_required("duckduckgo_search")
     def search_duckduckgo(
         self, query: str, source: str = "text", max_results: int = 5
@@ -151,7 +228,11 @@ class SearchToolkit(BaseToolkit):
         # If no answer found, return an empty list
         return responses
 
-    @api_keys_required("BRAVE_API_KEY")
+    @api_keys_required(
+        [
+            (None, 'BRAVE_API_KEY'),
+        ]
+    )
     def search_brave(
         self,
         q: str,
@@ -297,7 +378,12 @@ class SearchToolkit(BaseToolkit):
         data = response.json()["web"]
         return data
 
-    @api_keys_required("GOOGLE_API_KEY", "SEARCH_ENGINE_ID")
+    @api_keys_required(
+        [
+            (None, 'GOOGLE_API_KEY'),
+            (None, 'SEARCH_ENGINE_ID'),
+        ]
+    )
     def search_google(
         self, query: str, num_result_pages: int = 5
     ) -> List[Dict[str, Any]]:
@@ -429,8 +515,7 @@ class SearchToolkit(BaseToolkit):
         if not WOLFRAMALPHA_APP_ID:
             raise ValueError(
                 "`WOLFRAMALPHA_APP_ID` not found in environment "
-                "variables. Get `WOLFRAMALPHA_APP_ID` here: "
-                "`https://products.wolframalpha.com/api/`."
+                "variables. Get `WOLFRAMALPHA_APP_ID` here: `https://products.wolframalpha.com/api/`."
             )
 
         try:
@@ -618,6 +703,7 @@ class SearchToolkit(BaseToolkit):
         """
         return [
             FunctionTool(self.search_wiki),
+            FunctionTool(self.search_linkup),
             FunctionTool(self.search_google),
             FunctionTool(self.search_duckduckgo),
             FunctionTool(self.query_wolfram_alpha),

camel/toolkits/stripe_toolkit.py

@@ -36,7 +36,11 @@ class StripeToolkit(BaseToolkit):
         logger (Logger): a logger to write logs.
     """
 
-    @api_keys_required("STRIPE_API_KEY")
+    @api_keys_required(
+        [
+            (None, "STRIPE_API_KEY"),
+        ]
+    )
     def __init__(self, retries: int = 3):
         r"""Initializes the StripeToolkit with the specified number of
         retries.

camel/toolkits/twitter_toolkit.py

@@ -31,10 +31,12 @@ logger = get_logger(__name__)
 
 
 @api_keys_required(
-    "TWITTER_CONSUMER_KEY",
-    "TWITTER_CONSUMER_SECRET",
-    "TWITTER_ACCESS_TOKEN",
-    "TWITTER_ACCESS_TOKEN_SECRET",
+    [
+        (None, "TWITTER_CONSUMER_KEY"),
+        (None, "TWITTER_CONSUMER_SECRET"),
+        (None, "TWITTER_ACCESS_TOKEN"),
+        (None, "TWITTER_ACCESS_TOKEN_SECRET"),
+    ]
 )
 def create_tweet(
     text: str,
@@ -132,10 +134,12 @@ def create_tweet(
 
 
 @api_keys_required(
-    "TWITTER_CONSUMER_KEY",
-    "TWITTER_CONSUMER_SECRET",
-    "TWITTER_ACCESS_TOKEN",
-    "TWITTER_ACCESS_TOKEN_SECRET",
+    [
+        (None, "TWITTER_CONSUMER_KEY"),
+        (None, "TWITTER_CONSUMER_SECRET"),
+        (None, "TWITTER_ACCESS_TOKEN"),
+        (None, "TWITTER_ACCESS_TOKEN_SECRET"),
+    ]
 )
 def delete_tweet(tweet_id: str) -> str:
     r"""Deletes a tweet with the specified ID for an authorized user.
@@ -187,10 +191,12 @@ def delete_tweet(tweet_id: str) -> str:
 
 
 @api_keys_required(
-    "TWITTER_CONSUMER_KEY",
-    "TWITTER_CONSUMER_SECRET",
-    "TWITTER_ACCESS_TOKEN",
-    "TWITTER_ACCESS_TOKEN_SECRET",
+    [
+        (None, "TWITTER_CONSUMER_KEY"),
+        (None, "TWITTER_CONSUMER_SECRET"),
+        (None, "TWITTER_ACCESS_TOKEN"),
+        (None, "TWITTER_ACCESS_TOKEN_SECRET"),
+    ]
 )
 def get_my_user_profile() -> str:
     r"""Retrieves the authenticated user's Twitter profile info.
@@ -214,10 +220,12 @@ def get_my_user_profile() -> str:
 
 
 @api_keys_required(
-    "TWITTER_CONSUMER_KEY",
-    "TWITTER_CONSUMER_SECRET",
-    "TWITTER_ACCESS_TOKEN",
-    "TWITTER_ACCESS_TOKEN_SECRET",
+    [
+        (None, "TWITTER_CONSUMER_KEY"),
+        (None, "TWITTER_CONSUMER_SECRET"),
+        (None, "TWITTER_ACCESS_TOKEN"),
+        (None, "TWITTER_ACCESS_TOKEN_SECRET"),
+    ]
 )
 def get_user_by_username(username: str) -> str:
     r"""Retrieves one user's Twitter profile info by username (handle).

camel/types/__init__.py

@@ -33,10 +33,11 @@ from .openai_types import (
     ChatCompletion,
     ChatCompletionAssistantMessageParam,
     ChatCompletionChunk,
-    ChatCompletionFunctionMessageParam,
     ChatCompletionMessage,
     ChatCompletionMessageParam,
+    ChatCompletionMessageToolCall,
     ChatCompletionSystemMessageParam,
+    ChatCompletionToolMessageParam,
     ChatCompletionUserMessageParam,
     Choice,
     CompletionUsage,
@@ -62,7 +63,8 @@ __all__ = [
     'ChatCompletionSystemMessageParam',
     'ChatCompletionUserMessageParam',
     'ChatCompletionAssistantMessageParam',
-    'ChatCompletionFunctionMessageParam',
+    'ChatCompletionToolMessageParam',
+    'ChatCompletionMessageToolCall',
     'CompletionUsage',
     'OpenAIImageType',
     'OpenAIVisionDetailType',

camel/types/enums.py

@@ -142,6 +142,12 @@ class ModelType(UnifiedModelType, Enum):
     # DeepSeek models
     DEEPSEEK_CHAT = "deepseek-chat"
 
+    # InternLM models
+    INTERNLM3_LATEST = "internlm3-latest"
+    INTERNLM3_8B_INSTRUCT = "internlm3-8b-instruct"
+    INTERNLM2_5_LATEST = "internlm2.5-latest"
+    INTERNLM2_PRO_CHAT = "internlm2-pro-chat"
+
     def __str__(self):
         return self.value
 
@@ -161,7 +167,15 @@ class ModelType(UnifiedModelType, Enum):
     @property
     def support_native_tool_calling(self) -> bool:
         return any(
-            [self.is_openai, self.is_gemini, self.is_mistral, self.is_qwen]
+            [
+                self.is_openai,
+                self.is_gemini,
+                self.is_mistral,
+                self.is_qwen,
+                self.is_deepseek,
+                self.is_cohere,
+                self.is_internlm,
+            ]
         )
 
     @property
@@ -353,6 +367,15 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.DEEPSEEK_CHAT,
         }
 
+    @property
+    def is_internlm(self) -> bool:
+        return self in {
+            ModelType.INTERNLM3_LATEST,
+            ModelType.INTERNLM3_8B_INSTRUCT,
+            ModelType.INTERNLM2_5_LATEST,
+            ModelType.INTERNLM2_PRO_CHAT,
+        }
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
@@ -411,6 +434,10 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NVIDIA_MISTRAL_LARGE,
             ModelType.NVIDIA_MIXTRAL_8X7B,
             ModelType.QWEN_QWQ_32B,
+            ModelType.INTERNLM3_8B_INSTRUCT,
+            ModelType.INTERNLM3_LATEST,
+            ModelType.INTERNLM2_5_LATEST,
+            ModelType.INTERNLM2_PRO_CHAT,
         }:
             return 32_768
         elif self in {
@@ -634,6 +661,7 @@ class ModelPlatformType(Enum):
     NVIDIA = "nvidia"
     DEEPSEEK = "deepseek"
     SGLANG = "sglang"
+    INTERNLM = "internlm"
 
     @property
     def is_openai(self) -> bool:
@@ -736,6 +764,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is DeepSeek."""
         return self is ModelPlatformType.DEEPSEEK
 
+    @property
+    def is_internlm(self) -> bool:
+        r"""Returns whether this platform is InternLM."""
+        return self is ModelPlatformType.INTERNLM
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

camel/types/openai_types.py

@@ -16,10 +16,10 @@ from openai.types.chat.chat_completion import ChatCompletion, Choice
 from openai.types.chat.chat_completion_assistant_message_param import (
     ChatCompletionAssistantMessageParam,
 )
-from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
-from openai.types.chat.chat_completion_function_message_param import (
-    ChatCompletionFunctionMessageParam,
+from openai.types.chat.chat_completion_tool_message_param import (
+    ChatCompletionToolMessageParam,
 )
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 from openai.types.chat.chat_completion_message import ChatCompletionMessage
 from openai.types.chat.chat_completion_message_param import (
     ChatCompletionMessageParam,
@@ -33,6 +33,7 @@ from openai.types.chat.chat_completion_user_message_param import (
 from openai.types.completion_usage import CompletionUsage
 from openai.types.chat import ParsedChatCompletion
 from openai._types import NOT_GIVEN, NotGiven
+from openai.types.chat import ChatCompletionMessageToolCall
 
 Choice = Choice
 ChatCompletion = ChatCompletion
@@ -42,7 +43,8 @@ ChatCompletionMessageParam = ChatCompletionMessageParam
 ChatCompletionSystemMessageParam = ChatCompletionSystemMessageParam
 ChatCompletionUserMessageParam = ChatCompletionUserMessageParam
 ChatCompletionAssistantMessageParam = ChatCompletionAssistantMessageParam
-ChatCompletionFunctionMessageParam = ChatCompletionFunctionMessageParam
+ChatCompletionToolMessageParam = ChatCompletionToolMessageParam
+ChatCompletionMessageToolCall = ChatCompletionMessageToolCall
 CompletionUsage = CompletionUsage
 NOT_GIVEN = NOT_GIVEN
 NotGiven = NotGiven

camel/types/unified_model_type.py

@@ -113,6 +113,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a Qwen model."""
         return True
 
+    @property
+    def is_internlm(self) -> bool:
+        r"""Returns whether the model is a InternLM model."""
+        return True
+
     @property
     def support_native_structured_output(self) -> bool:
         r"""Returns whether the model supports native structured output."""

camel/utils/__init__.py

@@ -19,6 +19,7 @@ from .commons import (
     check_server_running,
     create_chunks,
     dependencies_required,
+    download_github_subdirectory,
     download_tasks,
     func_string_to_callable,
     generate_prompt_for_structured_output,
@@ -79,5 +80,6 @@ __all__ = [
     "track_agent",
     "handle_http_error",
     "get_pydantic_model",
+    "download_github_subdirectory",
     "generate_prompt_for_structured_output",
 ]

camel/utils/commons.py

@@ -21,6 +21,7 @@ import time
 import zipfile
 from functools import wraps
 from http import HTTPStatus
+from pathlib import Path
 from typing import (
     Any,
     Callable,
@@ -29,6 +30,7 @@ from typing import (
     Mapping,
     Optional,
     Set,
+    Tuple,
     Type,
     TypeVar,
     cast,
@@ -231,41 +233,79 @@ def is_module_available(module_name: str) -> bool:
         return False
 
 
-def api_keys_required(*required_keys: str) -> Callable[[F], F]:
-    r"""A decorator to check if the required API keys are
-    presented in the environment variables or as an instance attribute.
+def api_keys_required(
+    param_env_list: List[Tuple[Optional[str], str]],
+) -> Callable[[F], F]:
+    r"""A decorator to check if the required API keys are provided in the
+    environment variables or as function arguments.
 
     Args:
-        required_keys (str): The required API keys to be checked.
+        param_env_list (List[Tuple[Optional[str], str]]): A list of tuples
+            where each tuple contains a function argument name (as the first
+            element, or None) and the corresponding environment variable name
+            (as the second element) that holds the API key.
 
     Returns:
-        Callable[[F], F]: The original function with the added check
-            for required API keys.
+        Callable[[F], F]: The original function wrapped with the added check
+            for the required API keys.
 
     Raises:
-        ValueError: If any of the required API keys are missing in the
-            environment variables and the instance attribute.
+        ValueError: If any of the required API keys are missing, either
+            from the function arguments or environment variables.
 
     Example:
         ::
 
-            @api_keys_required('API_KEY_1', 'API_KEY_2')
-            def some_api_function():
-                # Function implementation...
+            @api_keys_required([
+                ('api_key_arg', 'API_KEY_1'),
+                ('another_key_arg', 'API_KEY_2'),
+                (None, 'API_KEY_3'),
+            ])
+            def some_api_function(api_key_arg=None, another_key_arg=None):
+                # Function implementation that requires API keys
     """
+    import inspect
 
     def decorator(func: F) -> F:
         @wraps(func)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
-            missing_environment_keys = [
-                k for k in required_keys if k not in os.environ
-            ]
-            if (
-                not (args and getattr(args[0], '_api_key', None))
-                and missing_environment_keys
-            ):
+            signature = inspect.signature(func)
+            bound_arguments = signature.bind(*args, **kwargs)
+            bound_arguments.apply_defaults()
+            arguments = bound_arguments.arguments
+
+            missing_keys = []
+            for param_name, env_var_name in param_env_list:
+                if not isinstance(env_var_name, str):
+                    raise TypeError(
+                        f"Environment variable name must be a string, got"
+                        f" {type(env_var_name)}"
+                    )
+
+                value = None
+                if (
+                    param_name
+                ):  # If param_name is provided, check function argument first
+                    if not isinstance(param_name, str):
+                        raise TypeError(
+                            f"Parameter name must be a string, "
+                            f"got {type(param_name)}"
+                        )
+                    value = arguments.get(param_name)
+                    # If we found a valid value in arguments, continue to next
+                    # item
+                    if value:
+                        continue
+
+                # Check environment variable if no valid value found yet
+                value = os.environ.get(env_var_name)
+                if not value or value.strip() == "":
+                    missing_keys.append(env_var_name)
+
+            if missing_keys:
                 raise ValueError(
-                    f"Missing API keys: {', '.join(missing_environment_keys)}"
+                    "Missing or empty required API keys in "
+                    f"environment variables: {', '.join(missing_keys)}"
                 )
             return func(*args, **kwargs)
 
@@ -609,6 +649,51 @@ def retry_request(
                 raise
 
 
+def download_github_subdirectory(
+    repo: str, subdir: str, data_dir: Path, branch="main"
+):
+    r"""Download subdirectory of the Github repo of
+    the benchmark.
+
+    This function downloads all files and subdirectories from a
+    specified subdirectory of a GitHub repository and
+    saves them to a local directory.
+
+    Args:
+        repo (str): The name of the GitHub repository
+                in the format "owner/repo".
+        subdir (str): The path to the subdirectory
+            within the repository to download.
+        data_dir (Path): The local directory where
+            the files will be saved.
+        branch (str, optional): The branch of the repository to use.
+            Defaults to "main".
+    """
+    from tqdm import tqdm
+
+    api_url = (
+        f"https://api.github.com/repos/{repo}/contents/{subdir}?ref={branch}"
+    )
+    headers = {"Accept": "application/vnd.github.v3+json"}
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+    files = response.json()
+    os.makedirs(data_dir, exist_ok=True)
+
+    for file in tqdm(files, desc="Downloading"):
+        file_path = data_dir / file["name"]
+
+        if file["type"] == "file":
+            file_url = file["download_url"]
+            file_response = requests.get(file_url)
+            with open(file_path, "wb") as f:
+                f.write(file_response.content)
+        elif file["type"] == "dir":
+            download_github_subdirectory(
+                repo, f'{subdir}/{file["name"]}', file_path, branch
+            )
+
+
 def generate_prompt_for_structured_output(
     response_format: Optional[Type[BaseModel]],
     user_message: str,

camel/utils/token_counting.py

@@ -253,11 +253,11 @@ class AnthropicTokenCounter(BaseTokenCounter):
         Returns:
             int: Number of tokens in the messages.
         """
-        from anthropic.types.beta import BetaMessageParam
+        from anthropic.types import MessageParam
 
-        return self.client.beta.messages.count_tokens(
+        return self.client.messages.count_tokens(
             messages=[
-                BetaMessageParam(
+                MessageParam(
                     content=str(msg["content"]),
                     role="user" if msg["role"] == "user" else "assistant",
                 )