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

camel/agents/chat_agent.py

@@ -19,14 +19,15 @@ from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Dict,
     List,
     Optional,
     Tuple,
+    Type,
     Union,
 )
 
+from openai.types.chat import ChatCompletionMessageToolCall
 from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
@@ -49,7 +50,6 @@ from camel.types import (
     RoleType,
 )
 from camel.utils import (
-    Constants,
     func_string_to_callable,
     get_model_encoding,
     get_pydantic_object_schema,
@@ -130,6 +130,10 @@ class ChatAgent(BaseAgent):
             agent. (default: :obj:`None`)
         tools (List[OpenAIFunction], optional): List of available
             :obj:`OpenAIFunction`. (default: :obj:`None`)
+        external_tools (List[OpenAIFunction], optional): List of external tools
+            (:obj:`OpenAIFunction`) bind to one chat agent. When these tools
+            are called, the agent will directly return the request instead of
+            processing it. (default: :obj:`None`)
         response_terminators (List[ResponseTerminator], optional): List of
             :obj:`ResponseTerminator` bind to one chat agent.
             (default: :obj:`None`)
@@ -144,6 +148,7 @@ class ChatAgent(BaseAgent):
         token_limit: Optional[int] = None,
         output_language: Optional[str] = None,
         tools: Optional[List[OpenAIFunction]] = None,
+        external_tools: Optional[List[OpenAIFunction]] = None,
         response_terminators: Optional[List[ResponseTerminator]] = None,
     ) -> None:
         self.orig_sys_message: BaseMessage = system_message
@@ -165,10 +170,16 @@ class ChatAgent(BaseAgent):
 
         self.model_type: ModelType = self.model_backend.model_type
 
-        self.func_dict: Dict[str, Callable] = {}
-        if tools is not None:
-            for func in tools:
-                self.func_dict[func.get_function_name()] = func.func
+        # tool registration
+        external_tools = external_tools or []
+        tools = tools or []
+        all_tools = tools + external_tools
+        self.external_tool_names = [
+            tool.get_function_name() for tool in external_tools
+        ]
+        self.func_dict = {
+            tool.get_function_name(): tool.func for tool in all_tools
+        }
 
         self.model_config_dict = self.model_backend.model_config_dict
 
@@ -262,34 +273,41 @@ class ChatAgent(BaseAgent):
 
     def get_info(
         self,
-        id: Optional[str],
+        session_id: Optional[str],
         usage: Optional[Dict[str, int]],
         termination_reasons: List[str],
         num_tokens: int,
         tool_calls: List[FunctionCallingRecord],
+        external_tool_request: Optional[ChatCompletionMessageToolCall] = None,
     ) -> Dict[str, Any]:
         r"""Returns a dictionary containing information about the chat session.
 
         Args:
-            id (str, optional): The ID of the chat session.
+            session_id (str, optional): The ID of the chat session.
             usage (Dict[str, int], optional): Information about the usage of
                 the LLM model.
             termination_reasons (List[str]): The reasons for the termination
                 of the chat session.
             num_tokens (int): The number of tokens used in the chat session.
             tool_calls (List[FunctionCallingRecord]): The list of function
-                calling records, containing the information of called
-                tools.
+                calling records, containing the information of called tools.
+            external_tool_request
+                (Optional[ChatCompletionMessageToolCall], optional):
+                The tool calling request of external tools from the model.
+                These requests are directly returned to the user instead of
+                being processed by the agent automatically.
+                (default: :obj:`None`)
 
         Returns:
             Dict[str, Any]: The chat session information.
         """
         return {
-            "id": id,
+            "id": session_id,
             "usage": usage,
             "termination_reasons": termination_reasons,
             "num_tokens": num_tokens,
             "tool_calls": tool_calls,
+            "external_tool_request": external_tool_request,
         }
 
     def init_messages(self) -> None:
@@ -317,7 +335,7 @@ class ChatAgent(BaseAgent):
     def step(
         self,
         input_message: BaseMessage,
-        output_schema: Optional[BaseModel] = None,
+        output_schema: Optional[Type[BaseModel]] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message.
@@ -328,10 +346,11 @@ class ChatAgent(BaseAgent):
                 either `user` or `assistant` but it will be set to `user`
                 anyway since for the self agent any incoming message is
                 external.
-            output_schema (Optional[BaseModel]): An optional pydantic model
-                that includes value types and field descriptions used to
-                generate a structured response by LLM. This schema helps
-                in defining the expected output format.
+            output_schema (Optional[Type[BaseModel]], optional): A pydantic
+                model class that includes value types and field descriptions
+                used to generate a structured response by LLM. This schema
+                helps in defining the expected output format. (default:
+                :obj:`None`)
 
         Returns:
             ChatAgentResponse: A struct containing the output messages,
@@ -340,27 +359,15 @@ class ChatAgent(BaseAgent):
         """
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
-        output_messages: List[BaseMessage]
-        info: Dict[str, Any]
-        tool_calls: List[FunctionCallingRecord] = []
+        tool_call_records: List[FunctionCallingRecord] = []
         while True:
-            # Format messages and get the token number
-            openai_messages: Optional[List[OpenAIMessage]]
-
+            # Check if token has exceeded
             try:
                 openai_messages, num_tokens = self.memory.get_context()
             except RuntimeError as e:
-                return self.step_token_exceed(
-                    e.args[1], tool_calls, "max_tokens_exceeded"
+                return self._step_token_exceed(
+                    e.args[1], tool_call_records, "max_tokens_exceeded"
                 )
-            # use structed output response without tools
-            # If the user provides the output_schema parameter and does not
-            # specify the use of tools, then in the model config of the
-            # chatgent, call the model specified by tools with
-            # return_json_response of OpenAIFunction format, and return a
-            # structured response with the user-specified output schema.
-            if output_schema is not None and len(self.func_dict) == 0:
-                self._add_output_schema_to_tool_list(output_schema)
 
             (
                 response,
@@ -370,97 +377,73 @@ class ChatAgent(BaseAgent):
                 response_id,
             ) = self._step_model_response(openai_messages, num_tokens)
 
+            # If the model response is not a function call, meaning the model
+            # has generated a message response, break the loop
             if (
-                self.is_tools_added()
-                and isinstance(response, ChatCompletion)
-                and response.choices[0].message.tool_calls is not None
+                not self.is_tools_added()
+                or not isinstance(response, ChatCompletion)
+                or response.choices[0].message.tool_calls is None
             ):
-                # Tools added for function calling and not in stream mode
-
-                tool_calls, func_assistant_msg, func_result_msg = (
-                    self._add_tools_for_func_call(response, tool_calls)
-                )
-
-                # Update the messages
-                self.update_memory(
-                    func_assistant_msg, OpenAIBackendRole.ASSISTANT
-                )
-                self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
-
-            else:
-                # If the user specifies tools, it is necessary to wait for the
-                # model to complete all tools' calls. Finally, use the
-                # generated response as the input for the structure,
-                # simultaneously calling the return_json_response function.
-                # Call the model again with return_json_response in the format
-                # of OpenAIFunction as the last tool, returning a structured
-                # response with the user-specified output schema.
-                if output_schema is not None and all(
-                    record.func_name
-                    != Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT
-                    for record in tool_calls
-                ):
-                    self._add_output_schema_to_tool_list(output_schema)
-
-                    (
-                        response,
-                        output_messages,
-                        finish_reasons,
-                        usage_dict,
-                        response_id,
-                    ) = self._step_model_response(openai_messages, num_tokens)
-
-                    if isinstance(response, ChatCompletion):
-                        # Tools added for function calling and not in stream
-                        # mode
-                        tool_calls, func_assistant_msg, func_result_msg = (
-                            self._add_tools_for_func_call(response, tool_calls)
-                        )
-
-                        # Update the messages
-                        self.update_memory(
-                            func_assistant_msg, OpenAIBackendRole.ASSISTANT
-                        )
-                        self.update_memory(
-                            func_result_msg, OpenAIBackendRole.FUNCTION
-                        )
+                break
 
+            # Check for external tool call
+            tool_call_request = response.choices[0].message.tool_calls[0]
+            if tool_call_request.function.name in self.external_tool_names:
+                # if model calls an external tool, directly return the request
                 info = self._step_get_info(
                     output_messages,
                     finish_reasons,
                     usage_dict,
                     response_id,
-                    tool_calls,
+                    tool_call_records,
                     num_tokens,
+                    tool_call_request,
+                )
+                return ChatAgentResponse(
+                    msgs=output_messages, terminated=self.terminated, info=info
                 )
-                break
 
-        # if use structure response, set structure result as content of
-        # BaseMessage
-        if output_schema and self.model_type.is_openai:
-            for base_message_item in output_messages:
-                base_message_item.content = str(info['tool_calls'][-1].result)
+            # Normal function calling
+            tool_call_records.append(self._step_tool_call_and_update(response))
 
-        chat_agent_response = ChatAgentResponse(
-            msgs=output_messages, terminated=self.terminated, info=info
+        if output_schema is not None and self.model_type.supports_tool_calling:
+            (
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+                tool_call,
+                num_tokens,
+            ) = self._structure_output_with_function(output_schema)
+            tool_call_records.append(tool_call)
+
+        info = self._step_get_info(
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+            tool_call_records,
+            num_tokens,
         )
 
-        # If the output result is single message, it will be
-        # automatically added to the memory.
-        if len(chat_agent_response.msgs) == 1:
-            self.record_message(chat_agent_response.msg)
+        if len(output_messages) == 1:
+            # Auto record if the output result is a single message
+            self.record_message(output_messages[0])
         else:
             logger.warning(
-                "Multiple messages are available in `ChatAgentResponse`. "
-                "Please manually run the `record_message` function to "
-                "record the selected message."
+                "Multiple messages returned in `step()`, message won't be "
+                "recorded automatically. Please call `record_message()` to "
+                "record the selected message manually."
             )
-        return chat_agent_response
+
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
 
     async def step_async(
         self,
         input_message: BaseMessage,
-        output_schema: Optional[BaseModel] = None,
+        output_schema: Optional[Type[BaseModel]] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message. This agent step can call async function calls.
@@ -471,10 +454,11 @@ class ChatAgent(BaseAgent):
                 either `user` or `assistant` but it will be set to `user`
                 anyway since for the self agent any incoming message is
                 external.
-            output_schema (Optional[BaseModel]): An optional pydantic model
-                that includes value types and field descriptions used to
-                generate a structured response by LLM. This schema helps
-                in defining the expected output format.
+            output_schema (Optional[Type[BaseModel]], optional): A pydantic
+                model class that includes value types and field descriptions
+                used to generate a structured response by LLM. This schema
+                helps in defining the expected output format. (default:
+                :obj:`None`)
 
         Returns:
             ChatAgentResponse: A struct containing the output messages,
@@ -483,21 +467,14 @@ class ChatAgent(BaseAgent):
         """
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
-        output_messages: List[BaseMessage]
-        info: Dict[str, Any]
-        tool_calls: List[FunctionCallingRecord] = []
+        tool_call_records: List[FunctionCallingRecord] = []
         while True:
-            # Format messages and get the token number
-            openai_messages: Optional[List[OpenAIMessage]]
-
             try:
                 openai_messages, num_tokens = self.memory.get_context()
             except RuntimeError as e:
-                return self.step_token_exceed(
-                    e.args[1], tool_calls, "max_tokens_exceeded"
+                return self._step_token_exceed(
+                    e.args[1], tool_call_records, "max_tokens_exceeded"
                 )
-            if output_schema is not None:
-                self._add_output_schema_to_tool_list(output_schema)
 
             (
                 response,
@@ -508,168 +485,168 @@ class ChatAgent(BaseAgent):
             ) = self._step_model_response(openai_messages, num_tokens)
 
             if (
-                self.is_tools_added()
-                and isinstance(response, ChatCompletion)
-                and response.choices[0].message.tool_calls is not None
+                not self.is_tools_added()
+                or not isinstance(response, ChatCompletion)
+                or response.choices[0].message.tool_calls is None
             ):
-                # Tools added for function calling and not in stream mode
-
-                # Do function calling
-                (
-                    func_assistant_msg,
-                    func_result_msg,
-                    func_record,
-                ) = await self.step_tool_call_async(response)
-
-                # Update the messages
-                self.update_memory(
-                    func_assistant_msg, OpenAIBackendRole.ASSISTANT
-                )
-                self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
-
-                # Record the function calling
-                tool_calls.append(func_record)
-
-            else:
-                # use structed output response without tools
-                if output_schema is not None and all(
-                    record.func_name
-                    != Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT
-                    for record in tool_calls
-                ):
-                    self._add_output_schema_to_tool_list(output_schema)
-
-                    (
-                        response,
-                        output_messages,
-                        finish_reasons,
-                        usage_dict,
-                        response_id,
-                    ) = self._step_model_response(openai_messages, num_tokens)
-
-                    if isinstance(response, ChatCompletion):
-                        # Tools added for function calling and not in stream
-                        # mode
-                        tool_calls, func_assistant_msg, func_result_msg = (
-                            self._add_tools_for_func_call(response, tool_calls)
-                        )
-
-                        # Update the messages
-                        self.update_memory(
-                            func_assistant_msg, OpenAIBackendRole.ASSISTANT
-                        )
-                        self.update_memory(
-                            func_result_msg, OpenAIBackendRole.FUNCTION
-                        )
-
-                # Function calling disabled or not a function calling
+                break
+
+            # Check for external tool call
+            tool_call_request = response.choices[0].message.tool_calls[0]
+            if tool_call_request.function.name in self.external_tool_names:
+                # if model calls an external tool, directly return the request
                 info = self._step_get_info(
                     output_messages,
                     finish_reasons,
                     usage_dict,
                     response_id,
-                    tool_calls,
+                    tool_call_records,
                     num_tokens,
+                    tool_call_request,
+                )
+                return ChatAgentResponse(
+                    msgs=output_messages, terminated=self.terminated, info=info
                 )
-                break
 
-        # if use structure response, set structure result as content of
-        # BaseMessage
-        if output_schema and self.model_type.is_openai:
-            for base_message_item in output_messages:
-                base_message_item.content = str(info['tool_calls'][0].result)
+            # Normal function calling
+            tool_call_records.append(
+                await self._step_tool_call_and_update_async(response)
+            )
 
-        chat_agent_response = ChatAgentResponse(
-            msgs=output_messages, terminated=self.terminated, info=info
+        if output_schema is not None and self.model_type.supports_tool_calling:
+            (
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+                tool_call_record,
+                num_tokens,
+            ) = self._structure_output_with_function(output_schema)
+            tool_call_records.append(tool_call_record)
+
+        info = self._step_get_info(
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+            tool_call_records,
+            num_tokens,
         )
 
-        # If the output result is single message, it will be
-        # automatically added to the memory.
-        if len(chat_agent_response.msgs) == 1:
-            self.record_message(chat_agent_response.msg)
+        if len(output_messages) == 1:
+            # Auto record if the output result is a single message
+            self.record_message(output_messages[0])
         else:
             logger.warning(
-                "Multiple messages are presented in `chat_agent_response`. "
-                "Please manually call the `record_message` function to "
-                "record the chosen message."
+                "Multiple messages returned in `step()`, message won't be "
+                "recorded automatically. Please call `record_message()` to "
+                "record the selected message manually."
             )
 
-        return chat_agent_response
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
+
+    def _step_tool_call_and_update(
+        self, response: ChatCompletion
+    ) -> FunctionCallingRecord:
+        r"""Processes a function call within the chat completion response,
+        records the function call in the provided list of tool calls and
+        updates the memory of the current agent.
 
-    def _add_tools_for_func_call(
-        self,
-        response: ChatCompletion,
-        tool_calls: List[FunctionCallingRecord],
-    ) -> tuple[
-        List[FunctionCallingRecord],
-        FunctionCallingMessage,
-        FunctionCallingMessage,
-    ]:
-        r"""
-        Handles adding tools for function calls based on the response.
-        This method processes a function call within the chat completion
-        response, and records the function call in the provided
-        list of tool calls.
         Args:
             response (ChatCompletion): The response object from the chat
                 completion.
-            tool_calls (List[FunctionCallingRecord]): The list to record
-                function calls.
+
         Returns:
-            tuple: A tuple containing:
-                - List[FunctionCallingRecord]: The updated list of function
-                  call records.
-                - FunctionCallingMessage: The assistant's message regarding the
-                  function call.
-                - FunctionCallingMessage: The result message of the function
-                  call.
+            FunctionCallingRecord: The record of calling the function.
         """
 
         # Perform function calling
-        func_assistant_msg, func_result_msg, func_record = self.step_tool_call(
-            response
+        func_assistant_msg, func_result_msg, tool_call_record = (
+            self.step_tool_call(response)
         )
 
-        # Record the function call in the list of tool calls
-        tool_calls.append(func_record)
+        # Update the messages
+        self.update_memory(func_assistant_msg, OpenAIBackendRole.ASSISTANT)
+        self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
 
-        # Return updated tool calls list, assistant's message, and function
-        # result message
-        return tool_calls, func_assistant_msg, func_result_msg
+        return tool_call_record
 
-    def _add_output_schema_to_tool_list(self, output_schema: BaseModel):
-        r"""Handles the structured output response for OpenAI.
-        This method processes the given output schema and integrates the
-        resulting function into the tools for the OpenAI model configuration.
-        Args:
-            output_schema (BaseModel): The schema representing the expected
-                output structure.
+    async def _step_tool_call_and_update_async(
+        self, response: ChatCompletion
+    ) -> FunctionCallingRecord:
+        (
+            func_assistant_msg,
+            func_result_msg,
+            func_record,
+        ) = await self.step_tool_call_async(response)
+
+        self.update_memory(func_assistant_msg, OpenAIBackendRole.ASSISTANT)
+        self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
+
+        return func_record
+
+    def _structure_output_with_function(
+        self, output_schema: Type[BaseModel]
+    ) -> Tuple[
+        List[BaseMessage],
+        List[str],
+        Dict[str, int],
+        str,
+        FunctionCallingRecord,
+        int,
+    ]:
+        r"""Internal function of structuring the output of the agent based on
+        the given output schema.
         """
         from camel.toolkits import OpenAIFunction
 
-        # step 1 extract the output_schema info as json.
         schema_json = get_pydantic_object_schema(output_schema)
-
-        # step 2 convert output schema json as callable string
         func_str = json_to_function_code(schema_json)
-
-        # step 3 get callable function from string
         func_callable = func_string_to_callable(func_str)
-
-        # step 4 add return_json_func into tools
         func = OpenAIFunction(func_callable)
-        tools = [func]
-        self.func_dict[func.get_function_name()] = func.func
-        if self.model_type.is_openai:
-            self.model_backend.model_config_dict = ChatGPTConfig(
-                tools=tools
-            ).as_dict()
-        elif self.model_type.is_gemini:
-            from camel.configs.gemini_config import GeminiConfig
-
-            self.model_backend.model_config_dict = GeminiConfig(
-                tools=tools
-            ).as_dict()
+
+        original_func_dict = self.func_dict
+        original_model_dict = self.model_backend.model_config_dict
+
+        # Replace the original tools with the structuring function
+        self.func_dict = {func.get_function_name(): func.func}
+        self.model_backend.model_config_dict["tools"] = [
+            func.get_openai_tool_schema()
+        ]
+
+        openai_messages, num_tokens = self.memory.get_context()
+        (
+            response,
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+        ) = self._step_model_response(openai_messages, num_tokens)
+
+        if isinstance(response, ChatCompletion):
+            tool_call_record = self._step_tool_call_and_update(response)
+        else:
+            raise ValueError(
+                "Structured output is not supported for stream responses."
+            )
+
+        for base_message_item in output_messages:
+            base_message_item.content = str(tool_call_record.result)
+
+        # Recover the original tools
+        self.func_dict = original_func_dict
+        self.model_backend.model_config_dict = original_model_dict
+
+        return (
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+            tool_call_record,
+            num_tokens,
+        )
 
     def _step_model_response(
         self,
@@ -710,6 +687,7 @@ class ChatAgent(BaseAgent):
         response_id: str,
         tool_calls: List[FunctionCallingRecord],
         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
@@ -737,6 +715,7 @@ class ChatAgent(BaseAgent):
             finish_reasons,
             num_tokens,
             tool_calls,
+            external_tool_request,
         )
         return info
 
@@ -830,7 +809,7 @@ class ChatAgent(BaseAgent):
         usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
         return output_messages, finish_reasons, usage_dict, response_id
 
-    def step_token_exceed(
+    def _step_token_exceed(
         self,
         num_tokens: int,
         tool_calls: List[FunctionCallingRecord],

camel/toolkits/reddit_toolkit.py

@@ -14,7 +14,7 @@
 
 import os
 import time
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Union
 
 from requests.exceptions import RequestException
 
@@ -50,20 +50,14 @@ class RedditToolkit(BaseToolkit):
         self.retries = retries
         self.delay = delay
 
-        client_id = os.environ.get("REDDIT_CLIENT_ID", "")
-        client_secret = os.environ.get("REDDIT_CLIENT_SECRET", "")
-        user_agent = os.environ.get("REDDIT_USER_AGENT", "")
-
-        if not all([client_id, client_secret, user_agent]):
-            print(
-                "Reddit API credentials are not set. "
-                "Please set the environment variables."
-            )
+        self.client_id = os.environ.get("REDDIT_CLIENT_ID", "")
+        self.client_secret = os.environ.get("REDDIT_CLIENT_SECRET", "")
+        self.user_agent = os.environ.get("REDDIT_USER_AGENT", "")
 
         self.reddit = Reddit(
-            client_id=client_id,
-            client_secret=client_secret,
-            user_agent=user_agent,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            user_agent=self.user_agent,
             request_timeout=30,  # Set a timeout to handle delays
         )
 
@@ -96,7 +90,7 @@ class RedditToolkit(BaseToolkit):
         subreddit_name: str,
         post_limit: int = 5,
         comment_limit: int = 5,
-    ) -> List[Dict[str, Any]]:
+    ) -> Union[List[Dict[str, Any]], str]:
         r"""Collects the top posts and their comments from a specified
         subreddit.
 
@@ -109,9 +103,16 @@ class RedditToolkit(BaseToolkit):
                 per post. Defaults to `5`.
 
         Returns:
-            List[Dict[str, Any]]: A list of dictionaries, each containing the
-                post title and its top comments.
+            Union[List[Dict[str, Any]], str]: A list of dictionaries, each
+                containing the post title and its top comments if success.
+                String warming if credentials are not set.
         """
+        if not all([self.client_id, self.client_secret, self.user_agent]):
+            return (
+                "Reddit API credentials are not set. "
+                "Please set the environment variables."
+            )
+
         subreddit = self._retry_request(self.reddit.subreddit, subreddit_name)
         top_posts = self._retry_request(subreddit.top, limit=post_limit)
         data = []
@@ -162,7 +163,7 @@ class RedditToolkit(BaseToolkit):
         post_limit: int = 10,
         comment_limit: int = 10,
         sentiment_analysis: bool = False,
-    ) -> List[Dict[str, Any]]:
+    ) -> Union[List[Dict[str, Any]], str]:
         r"""Tracks discussions about specific keywords in specified subreddits.
 
         Args:
@@ -177,10 +178,17 @@ class RedditToolkit(BaseToolkit):
                 the comments. Defaults to `False`.
 
         Returns:
-            List[Dict[str, Any]]: A list of dictionaries containing the
-                subreddit name, post title, comment body, and upvotes for each
-                comment that contains the specified keywords.
+            Union[List[Dict[str, Any]], str]: A list of dictionaries
+                containing the subreddit name, post title, comment body, and
+                upvotes for each comment that contains the specified keywords
+                if success. String warming if credentials are not set.
         """
+        if not all([self.client_id, self.client_secret, self.user_agent]):
+            return (
+                "Reddit API credentials are not set. "
+                "Please set the environment variables."
+            )
+
         data = []
 
         for subreddit_name in subreddits:

camel/types/enums.py

@@ -92,6 +92,10 @@ class ModelType(Enum):
             return self.value
         return "gpt-4o-mini"
 
+    @property
+    def supports_tool_calling(self) -> bool:
+        return any([self.is_openai, self.is_gemini, self.is_mistral])
+
     @property
     def is_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model."""

camel/utils/commons.py

@@ -29,6 +29,7 @@ from typing import (
     Mapping,
     Optional,
     Set,
+    Type,
     TypeVar,
     cast,
 )
@@ -329,12 +330,12 @@ def get_pydantic_major_version() -> int:
         return 0
 
 
-def get_pydantic_object_schema(pydantic_params: BaseModel) -> Dict:
+def get_pydantic_object_schema(pydantic_params: Type[BaseModel]) -> Dict:
     r"""Get the JSON schema of a Pydantic model.
 
     Args:
-        pydantic_params (BaseModel): The Pydantic model to retrieve the schema
-            for.
+        pydantic_params (Type[BaseModel]): The Pydantic model class to retrieve
+            the schema for.
 
     Returns:
         dict: The JSON schema of the Pydantic model.
@@ -354,7 +355,7 @@ def func_string_to_callable(code: str):
     """
     local_vars: Mapping[str, object] = {}
     exec(code, globals(), local_vars)
-    func = local_vars.get(Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT)
+    func = local_vars.get(Constants.FUNC_NAME_FOR_STRUCTURED_OUTPUT)
     return func
 
 
@@ -397,7 +398,7 @@ def json_to_function_code(json_obj: Dict) -> str:
 
     # function template
     function_code = f'''
-def {Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT}({args_str}):
+def {Constants.FUNC_NAME_FOR_STRUCTURED_OUTPUT}({args_str}):
     r"""Return response with a specified json format.
     Args:
 {docstring_args_str}

camel/utils/constants.py

@@ -26,7 +26,7 @@ class Constants:
     VIDEO_DEFAULT_PLUG_PYAV = "pyav"
 
     # Return response with json format
-    FUNC_NAME_FOR_STRUCTURE_OUTPUT = "return_json_response"
+    FUNC_NAME_FOR_STRUCTURED_OUTPUT = "return_json_response"
 
     # Default top k vaule for RAG
     DEFAULT_TOP_K_RESULTS = 1

{camel_ai-0.1.7.1.dist-info → camel_ai-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.1.7.1
+Version: 0.1.8
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -213,7 +213,7 @@ conda create --name camel python=3.10
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.7.1 https://github.com/camel-ai/camel.git
+git clone -b v0.1.8 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel

{camel_ai-0.1.7.1.dist-info → camel_ai-0.1.8.dist-info}/RECORD

@@ -1,7 +1,7 @@
-camel/__init__.py,sha256=k-CsaXT5OFrrhnD7hKaxlVmf_Y2ACKAgKY8Mi3sqmP0,780
+camel/__init__.py,sha256=LIlV3O5R-G_rJo3VJCy1pfsbJTHL2EOHf6G78HpJgqs,778
 camel/agents/__init__.py,sha256=SSU1wbhZXWwQnE0rRxkpyN57kEu72KklsZNcdLkXfTs,1551
 camel/agents/base.py,sha256=X39qWSiT1WnDqaJ9k3gQrTpOQSwUKzNEVpp5AY6fDH8,1130
-camel/agents/chat_agent.py,sha256=bfmj5PFu6Q2NVlHbPnQ6Re5_fslNyOFhSjsegq1Qdvc,37563
+camel/agents/chat_agent.py,sha256=ikYGo5ahcmubb5OHNcHlehTC0adnGxCMx0iKPnyUYoU,35760
 camel/agents/critic_agent.py,sha256=To-istnO-9Eb0iabdeIDrgfvkxYYfsdX9xIZiSrc3oM,7493
 camel/agents/deductive_reasoner_agent.py,sha256=49vwglWYHgXf-VRftdMN9OFGOwqdsXyTt45PP6z-pbg,13473
 camel/agents/embodied_agent.py,sha256=3ABuiRQXBpplKbuhPY5KNLJyKc6Z8SgXgzIges3ZwVs,7542
@@ -167,19 +167,19 @@ camel/toolkits/open_api_specs/web_scraper/paths/__init__.py,sha256=f3LXNDzN2XWWo
 camel/toolkits/open_api_specs/web_scraper/paths/scraper.py,sha256=SQGbFkshLN4xm-Ya49ssbSvaU1nFVNFYhWsEPYVeFe0,1123
 camel/toolkits/open_api_toolkit.py,sha256=rbQrhY6gHoZi9kiX9138pah9qZ2S8K5Vex1zFGWeCK8,23403
 camel/toolkits/openai_function.py,sha256=eaE441qxLvuRKr_WrpYLGkr5P2Nav07VVdR29n76RkU,14767
-camel/toolkits/reddit_toolkit.py,sha256=ohycaCMZkVNlmv9cCv4n2yFAYN0pcxTmV9Z0_a6dYuc,8511
+camel/toolkits/reddit_toolkit.py,sha256=FMHK7k9UHN-IqdabqyBavpo0ZOloveuPsOe3Ou-tq4o,8975
 camel/toolkits/retrieval_toolkit.py,sha256=UFByIxMB8m_C8HH-a65MeBJJACoJcVrcKMU9TGzm_SI,3828
 camel/toolkits/search_toolkit.py,sha256=vXe026bQpLic09iwY5PN4RS6SXeHYBBkjfnOlJYB670,12943
 camel/toolkits/slack_toolkit.py,sha256=JdgDJe7iExTmG7dDXOG6v5KpVjZ6_My_d_WFTYSxkw4,10839
 camel/toolkits/twitter_toolkit.py,sha256=oQw8wRkU7iDxaocsmWvio4pU75pmq6FJAorPdQ2xEAE,19810
 camel/toolkits/weather_toolkit.py,sha256=n4YrUI_jTIH7oqH918IdHbXLgfQ2BPGIWWK8Jp8G1Uw,7054
 camel/types/__init__.py,sha256=ArKXATj3z_Vv4ISmROVeo6Mv3tj5kE1dTkqfgwyxVY4,1975
-camel/types/enums.py,sha256=VjGUAPPJ2rEjNU-16radtPMeWSoTtPDMDMIo0PhMzaE,17328
+camel/types/enums.py,sha256=Nx35qNmjRTwT_B6uceZ3BtwxthrRqbRRnOk558_vQUk,17458
 camel/types/openai_types.py,sha256=BNQ6iCzKTjSvgcXFsAFIgrUS_YUFZBU6bDoyAp387hI,2045
 camel/utils/__init__.py,sha256=IdI9v0FetNR-nx-Hg4bmNHoYto6Xfcs_uaomksdewmo,2303
 camel/utils/async_func.py,sha256=SLo8KPkrNKdsONvFf3KBb33EgFn4gH2EKSX1aI_LKes,1578
-camel/utils/commons.py,sha256=cTg5yQEdVnqqf0oYa-EUp7Qv0RIBcPD6kSNNJ52UmPw,16451
-camel/utils/constants.py,sha256=p3_to59l7-pJPVsZ1rAhBO5kQyZMKFq1A6LdnvGGoz4,1359
+camel/utils/commons.py,sha256=y7eng5QF5Hkt5tuNhtEOJycTIq9hXymrUuwIS5nRad4,16481
+camel/utils/constants.py,sha256=8n4F8Y-DZy4z2F0hRvAq6f-d9SbS59kK5FyLrnJ3mkY,1360
 camel/utils/token_counting.py,sha256=G7vBzrxSXm4DzHMOfMXaOYjYf8WJTpxjHjlzmngHlYQ,21004
 camel/workforce/__init__.py,sha256=6jwJWDlESEqcnWCm61WCyjzFUF6KLzXA_fGI86rHfiE,878
 camel/workforce/base.py,sha256=lEHqgOV1tmsy7y4wuuKClcDkoPCRvXVdMrBngsM_6yY,1722
@@ -191,6 +191,6 @@ camel/workforce/utils.py,sha256=Z-kODz5PMPtfeKKVqpcQq-b-B8oqC7XSwi_F3__Ijhs,3526
 camel/workforce/worker_node.py,sha256=wsRqk2rugCvvkcmCzvn-y-gQuyuJGAG8PIr1KtgqJFw,3878
 camel/workforce/workforce.py,sha256=SVJJgSSkYvk05RgL9oaJzHwzziH7u51KLINRuzLB8BI,1773
 camel/workforce/workforce_prompt.py,sha256=cAWYEIA0rau5itEekSoUIFttBzpKM9RzB6x-mfukGSU,4665
-camel_ai-0.1.7.1.dist-info/METADATA,sha256=3i7AY4MF6i73MWDFeha6lKhQLS53kjUqIpWteg7HFPU,24658
-camel_ai-0.1.7.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-camel_ai-0.1.7.1.dist-info/RECORD,,
+camel_ai-0.1.8.dist-info/METADATA,sha256=ceVYBfVAJD9y8zBVbAMJmFC2omjmZlvftsFxVTHBtHU,24654
+camel_ai-0.1.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+camel_ai-0.1.8.dist-info/RECORD,,