camel-ai 0.2.21__py3-none-any.whl → 0.2.23a0__py3-none-any.whl

camel/toolkits/openbb_toolkit.py

@@ -37,15 +37,16 @@ class OpenBBToolkit(BaseToolkit):
             (None, "OPENBB_TOKEN"),
         ]
     )
-    def __init__(self) -> None:
+    def __init__(self, timeout: Optional[float] = None) -> None:
         r"""Initialize the OpenBBToolkit.
 
         This method sets up the OpenBB client and initializes the OpenBB
         Hub account system.
         """
+        super().__init__(timeout=timeout)
         import os
 
-        from openbb import obb
+        from openbb import obb  # type: ignore[import-not-found]
 
         self.client = obb
         # Initialize OpenBB Hub account with access token

camel/toolkits/reddit_toolkit.py

@@ -14,7 +14,7 @@
 
 import os
 import time
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
@@ -30,11 +30,16 @@ class RedditToolkit(BaseToolkit):
 
     Attributes:
         retries (int): Number of retries for API requests in case of failure.
-        delay (int): Delay between retries in seconds.
+        delay (float): Delay between retries in seconds.
         reddit (Reddit): An instance of the Reddit client.
     """
 
-    def __init__(self, retries: int = 3, delay: int = 0):
+    def __init__(
+        self,
+        retries: int = 3,
+        delay: float = 0.0,
+        timeout: Optional[float] = None,
+    ):
         r"""Initializes the RedditToolkit with the specified number of retries
         and delay.
 
@@ -43,7 +48,10 @@ class RedditToolkit(BaseToolkit):
                 failure. Defaults to `3`.
             delay (int): Time in seconds to wait between retries. Defaults to
             `0`.
+            timeout (float): Timeout for API requests in seconds. Defaults to
+                `None`.
         """
+        super().__init__(timeout=timeout)
         from praw import Reddit  # type: ignore[import-untyped]
 
         self.retries = retries

camel/toolkits/retrieval_toolkit.py

@@ -27,8 +27,13 @@ class RetrievalToolkit(BaseToolkit):
     storage system based on a specified query.
     """
 
-    def __init__(self, auto_retriever: Optional[AutoRetriever] = None) -> None:
+    def __init__(
+        self,
+        auto_retriever: Optional[AutoRetriever] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
         r"""Initializes a new instance of the RetrievalToolkit class."""
+        super().__init__(timeout=timeout)
         self.ar = auto_retriever or AutoRetriever(
             vector_storage_local_path="camel/temp_storage",
             storage_type=StorageType.QDRANT,

camel/toolkits/semantic_scholar_toolkit.py

@@ -26,8 +26,9 @@ class SemanticScholarToolkit(BaseToolkit):
     API to fetch paper and author data.
     """
 
-    def __init__(self):
+    def __init__(self, timeout: Optional[float] = None):
         r"""Initializes the SemanticScholarToolkit."""
+        super().__init__(timeout=timeout)
         self.base_url = "https://api.semanticscholar.org/graph/v1"
 
     def fetch_paper_data_title(

camel/toolkits/stripe_toolkit.py

@@ -15,7 +15,7 @@
 import json
 import logging
 import os
-from typing import List
+from typing import List, Optional
 
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
@@ -41,7 +41,12 @@ class StripeToolkit(BaseToolkit):
             (None, "STRIPE_API_KEY"),
         ]
     )
-    def __init__(self, retries: int = 3):
+    def __init__(
+        self,
+        retries: int = 3,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(timeout=timeout)
         r"""Initializes the StripeToolkit with the specified number of
         retries.
 
@@ -49,6 +54,7 @@ class StripeToolkit(BaseToolkit):
             retries (int,optional): Number of times to retry the request in
                 case of failure. (default: :obj:`3`)
         """
+        super().__init__(timeout=timeout)
         import stripe
 
         stripe.max_network_retries = retries

camel/toolkits/sympy_toolkit.py

@@ -28,13 +28,18 @@ class SymPyToolkit(BaseToolkit):
     and Linear Algebra.
     """
 
-    def __init__(self, default_variable: str = 'x'):
+    def __init__(
+        self,
+        default_variable: str = 'x',
+        timeout: Optional[float] = None,
+    ):
         r"""Initializes the toolkit with a default variable and logging.
 
         Args:
             default_variable (str): The default variable for
                 operations (default: :obj: `x`)
         """
+        super().__init__(timeout=timeout)
         self.default_variable = default_variable
         logger.info(f"Default variable set to: {self.default_variable}")
 
@@ -721,6 +726,43 @@ class SymPyToolkit(BaseToolkit):
         except Exception as e:
             return self.handle_exception("compute_rank", e)
 
+    def compute_inner_product(
+        self, vector1: List[float], vector2: List[float]
+    ) -> str:
+        r"""Computes the inner (dot) product of two vectors.
+
+        Args:
+            vector1 (List[float]): The first vector as a list of floats.
+            vector2 (List[float]): The second vector as a list of floats.
+
+        Returns:
+            str: JSON string containing the inner product in the `"result"`
+                field. If an error occurs, the JSON string will include an
+                `"error"` field with the corresponding error message.
+
+        Raises:
+            ValueError: If the vectors have different dimensions.
+        """
+        import sympy as sp
+
+        try:
+            # Convert the lists into sympy Matrix objects (column vectors)
+            v1 = sp.Matrix(vector1)
+            v2 = sp.Matrix(vector2)
+
+            # Check that the vectors have the same dimensions.
+            if v1.shape != v2.shape:
+                raise ValueError(
+                    "Vectors must have the same dimensions to compute "
+                    "the inner product."
+                )
+
+            # Compute the dot (inner) product.
+            inner_product = v1.dot(v2)
+            return json.dumps({"result": str(inner_product)})
+        except Exception as e:
+            return self.handle_exception("compute_inner_product", e)
+
     def handle_exception(self, func_name: str, error: Exception) -> str:
         r"""Handles exceptions by logging and returning error details.
 
@@ -775,4 +817,5 @@ class SymPyToolkit(BaseToolkit):
             FunctionTool(self.compute_eigenvectors),
             FunctionTool(self.compute_nullspace),
             FunctionTool(self.compute_rank),
+            FunctionTool(self.compute_inner_product),
         ]

camel/toolkits/video_toolkit.py

@@ -85,7 +85,9 @@ class VideoDownloaderToolkit(BaseToolkit):
         self,
         download_directory: Optional[str] = None,
         cookies_path: Optional[str] = None,
+        timeout: Optional[float] = None,
     ) -> None:
+        super().__init__(timeout=timeout)
         self._cleanup = download_directory is None
         self._cookies_path = cookies_path
 

camel/toolkits/whatsapp_toolkit.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 import requests
 
@@ -36,8 +36,9 @@ class WhatsAppToolkit(BaseToolkit):
         version (str): API version.
     """
 
-    def __init__(self):
+    def __init__(self, timeout: Optional[float] = None):
         r"""Initializes the WhatsAppToolkit."""
+        super().__init__(timeout=timeout)
         self.base_url = "https://graph.facebook.com"
         self.version = "v17.0"
 

camel/toolkits/zapier_toolkit.py

@@ -0,0 +1,191 @@
+# ========= 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 os
+from typing import Any, Dict, List
+
+import requests
+
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import api_keys_required, dependencies_required
+
+
+class ZapierToolkit(BaseToolkit):
+    r"""A class representing a toolkit for interacting with Zapier's NLA API.
+
+    This class provides methods for executing Zapier actions through natural
+    language commands, allowing integration with various web services and
+    automation of workflows through the Zapier platform.
+
+    Attributes:
+        api_key (str): The API key for authenticating with Zapier's API.
+        base_url (str): The base URL for Zapier's API endpoints.
+    """
+
+    @dependencies_required("requests")
+    @api_keys_required(
+        [
+            (None, "ZAPIER_NLA_API_KEY"),
+        ]
+    )
+    def __init__(self) -> None:
+        r"""Initialize the ZapierToolkit with API client. The API key is
+        retrieved from environment variables.
+        """
+        self.api_key = os.environ.get("ZAPIER_NLA_API_KEY")
+        self.base_url = "https://actions.zapier.com/api/v1/"
+
+    def list_actions(self) -> Dict[str, Any]:
+        r"""List all available Zapier actions.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the list of available
+                actions.
+        """
+        headers = {
+            'accept': 'application/json',
+            'x-api-key': self.api_key,
+        }
+        response = requests.get(
+            f"{self.base_url}exposed/",
+            params={'api_key': self.api_key},
+            headers=headers,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def execute_action(
+        self,
+        action_id: str,
+        instructions: str,
+    ) -> Dict[str, Any]:
+        r"""Execute a specific Zapier action using natural language
+        instructions.
+
+        Args:
+            action_id (str): The ID of the Zapier action to execute.
+            instructions (str): Natural language instructions for executing
+                the action. For example: "Send an email to john@example.com
+                with subject 'Hello' and body 'How are you?'"
+
+        Returns:
+            Dict[str, Any]: The result of the action execution, including
+                status and any output data.
+        """
+        try:
+            headers = {
+                'accept': 'application/json',
+                'x-api-key': self.api_key,
+                'Content-Type': 'application/json',
+            }
+            data = {
+                "instructions": instructions,
+                "preview_only": False,
+            }
+            response = requests.post(
+                f"{self.base_url}exposed/{action_id}/execute/",
+                params={'api_key': self.api_key},
+                headers=headers,
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {e!s}"}
+        except ValueError:
+            return {"error": "Response is not valid JSON"}
+
+    def preview_action(
+        self,
+        action_id: str,
+        instructions: str,
+    ) -> Dict[str, Any]:
+        r"""Preview a specific Zapier action using natural language
+        instructions.
+
+        Args:
+            action_id (str): The ID of the Zapier action to preview.
+            instructions (str): Natural language instructions for previewing
+                the action. For example: "Send an email to john@example.com
+                with subject 'Hello' and body 'How are you?'"
+
+        Returns:
+            Dict[str, Any]: The preview result showing what parameters would
+                be used if the action were executed.
+        """
+        try:
+            headers = {
+                'accept': 'application/json',
+                'x-api-key': self.api_key,
+                'Content-Type': 'application/json',
+            }
+            data = {
+                "instructions": instructions,
+                "preview_only": True,
+            }
+            response = requests.post(
+                f"{self.base_url}exposed/{action_id}/execute/",
+                params={'api_key': self.api_key},
+                headers=headers,
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {e!s}"}
+        except ValueError:
+            return {"error": "Response is not valid JSON"}
+
+    def get_execution_result(self, execution_id: str) -> Dict[str, Any]:
+        r"""Get the execution result of a Zapier action.
+
+        Args:
+            execution_id (str): The execution ID returned from execute_action.
+
+        Returns:
+            Dict[str, Any]: The execution result containing status, logs,
+                and any output data from the action execution.
+        """
+        try:
+            headers = {
+                'accept': 'application/json',
+                'x-api-key': self.api_key,
+            }
+            response = requests.get(
+                f"{self.base_url}execution-log/{execution_id}/",
+                params={'api_key': self.api_key},
+                headers=headers,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {e!s}"}
+        except ValueError:
+            return {"error": "Response is not valid JSON"}
+
+    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 representing
+                the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.list_actions),
+            FunctionTool(self.execute_action),
+            FunctionTool(self.preview_action),
+            FunctionTool(self.get_execution_result),
+        ]

camel/types/__init__.py

@@ -73,8 +73,8 @@ __all__ = [
     'AudioModelType',
     'VoiceType',
     'UnifiedModelType',
-    'NOT_GIVEN',
-    'NotGiven',
     'ParsedChatCompletion',
     'HuggingFaceRepoType',
+    'NOT_GIVEN',
+    'NotGiven',
 ]

camel/types/agents/__init__.py

@@ -0,0 +1,16 @@
+# ========= 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. =========
+from .tool_calling_record import ToolCallingRecord
+
+__all__ = ["ToolCallingRecord"]

camel/types/agents/tool_calling_record.py

@@ -0,0 +1,52 @@
+# ========= 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. =========
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+
+class ToolCallingRecord(BaseModel):
+    r"""Historical records of tools called in the conversation.
+
+    Attributes:
+        func_name (str): The name of the tool being called.
+        args (Dict[str, Any]): The dictionary of arguments passed to the tool.
+        result (Any): The execution result of calling this tool.
+        tool_call_id (str): The ID of the tool call, if available.
+    """
+
+    tool_name: str
+    args: Dict[str, Any]
+    result: Any
+    tool_call_id: str
+
+    def __str__(self) -> str:
+        r"""Overridden version of the string function.
+
+        Returns:
+            str: Modified string to represent the tool calling.
+        """
+        return (
+            f"Tool Execution: {self.tool_name}\n"
+            f"\tArgs: {self.args}\n"
+            f"\tResult: {self.result}\n"
+        )
+
+    def as_dict(self) -> dict[str, Any]:
+        r"""Returns the tool calling record as a dictionary.
+
+        Returns:
+            dict[str, Any]: The tool calling record as a dictionary.
+        """
+        return self.model_dump()

camel/types/enums.py

@@ -34,6 +34,7 @@ class ModelType(UnifiedModelType, Enum):
     GPT_4_TURBO = "gpt-4-turbo"
     GPT_4O = "gpt-4o"
     GPT_4O_MINI = "gpt-4o-mini"
+    GPT_4_5_PREVIEW = "gpt-4.5-preview"
     O1 = "o1"
     O1_PREVIEW = "o1-preview"
     O1_MINI = "o1-mini"
@@ -263,6 +264,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.O1_PREVIEW,
             ModelType.O1_MINI,
             ModelType.O3_MINI,
+            ModelType.GPT_4_5_PREVIEW,
         }
 
     @property
@@ -623,6 +625,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GPT_4_TURBO,
             ModelType.O1_PREVIEW,
             ModelType.O1_MINI,
+            ModelType.GPT_4_5_PREVIEW,
             ModelType.MISTRAL_LARGE,
             ModelType.MISTRAL_NEMO,
             ModelType.MISTRAL_PIXTRAL_12B,

camel/types/openai_types.py

@@ -35,17 +35,19 @@ from openai.types.chat import ParsedChatCompletion
 from openai._types import NOT_GIVEN, NotGiven
 from openai.types.chat import ChatCompletionMessageToolCall
 
-Choice = Choice
-ChatCompletion = ChatCompletion
-ChatCompletionChunk = ChatCompletionChunk
-ChatCompletionMessage = ChatCompletionMessage
-ChatCompletionMessageParam = ChatCompletionMessageParam
-ChatCompletionSystemMessageParam = ChatCompletionSystemMessageParam
-ChatCompletionUserMessageParam = ChatCompletionUserMessageParam
-ChatCompletionAssistantMessageParam = ChatCompletionAssistantMessageParam
-ChatCompletionToolMessageParam = ChatCompletionToolMessageParam
-ChatCompletionMessageToolCall = ChatCompletionMessageToolCall
-CompletionUsage = CompletionUsage
-NOT_GIVEN = NOT_GIVEN
-NotGiven = NotGiven
-ParsedChatCompletion = ParsedChatCompletion
+__all__ = [
+    "Choice",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "ChatCompletionMessage",
+    "ChatCompletionMessageParam",
+    "ChatCompletionSystemMessageParam",
+    "ChatCompletionUserMessageParam",
+    "ChatCompletionAssistantMessageParam",
+    "ChatCompletionToolMessageParam",
+    "ChatCompletionMessageToolCall",
+    "CompletionUsage",
+    "ParsedChatCompletion",
+    "NOT_GIVEN",
+    "NotGiven",
+]

camel/utils/__init__.py

@@ -23,7 +23,6 @@ from .commons import (
     download_github_subdirectory,
     download_tasks,
     func_string_to_callable,
-    generate_prompt_for_structured_output,
     get_first_int,
     get_prompt_template_key_words,
     get_pydantic_major_version,
@@ -38,6 +37,7 @@ from .commons import (
     text_extract_from_web,
     to_pascal,
     track_agent,
+    with_timeout,
 )
 from .constants import Constants
 from .deduplication import DeduplicationResult, deduplicate_internally
@@ -87,4 +87,5 @@ __all__ = [
     "DeduplicationResult",
     "retry_on_error",
     "BatchProcessor",
+    "with_timeout",
 ]

camel/utils/async_func.py

@@ -33,8 +33,8 @@ def sync_funcs_to_async(funcs: list[FunctionTool]) -> list[FunctionTool]:
     for func in funcs:
         sync_func = func.func
 
-        def async_callable(*args, **kwargs):
-            return asyncio.to_thread(sync_func, *args, **kwargs)  # noqa: B023
+        async def async_callable(*args, **kwargs):
+            return await asyncio.to_thread(sync_func, *args, **kwargs)  # noqa: B023
 
         async_funcs.append(
             FunctionTool(async_callable, deepcopy(func.openai_tool_schema))