Feature/support conditional tool calling

camel/agents/chat_agent.py

@@ -63,7 +63,7 @@
     from openai import Stream
 
     from camel.terminators import ResponseTerminator
-    from camel.toolkits import OpenAIFunction
+    from camel.toolkits import FunctionTool
 
 
 logger = logging.getLogger(__name__)
@@ -115,7 +115,8 @@ class ChatAgent(BaseAgent):
     r"""Class for managing conversations of CAMEL Chat Agents.
 
     Args:
-        system_message (BaseMessage): The system message for the chat agent.
+        system_message (BaseMessage, optional): The system message for the
+            chat agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
             `GPT_4O_MINI`)
@@ -131,10 +132,10 @@ class ChatAgent(BaseAgent):
             (default: :obj:`None`)
         output_language (str, optional): The language to be output by the
             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
+        tools (List[FunctionTool], optional): List of available
+            :obj:`FunctionTool`. (default: :obj:`None`)
+        external_tools (List[FunctionTool], optional): List of external tools
+            (:obj:`FunctionTool`) 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
@@ -144,20 +145,24 @@ class ChatAgent(BaseAgent):
 
     def __init__(
         self,
-        system_message: BaseMessage,
+        system_message: Optional[BaseMessage] = None,
         model: Optional[BaseModelBackend] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
         token_limit: Optional[int] = None,
         output_language: Optional[str] = None,
-        tools: Optional[List[OpenAIFunction]] = None,
-        external_tools: Optional[List[OpenAIFunction]] = None,
+        tools: Optional[List[FunctionTool]] = None,
+        external_tools: Optional[List[FunctionTool]] = None,
         response_terminators: Optional[List[ResponseTerminator]] = None,
     ) -> None:
-        self.orig_sys_message: BaseMessage = system_message
-        self.system_message = system_message
-        self.role_name: str = system_message.role_name
-        self.role_type: RoleType = system_message.role_type
+        self.orig_sys_message: Optional[BaseMessage] = system_message
+        self._system_message: Optional[BaseMessage] = system_message
+        self.role_name: str = (
+            getattr(system_message, 'role_name', None) or "assistant"
+        )
+        self.role_type: RoleType = (
+            getattr(system_message, 'role_type', None) or RoleType.ASSISTANT
+        )
         self.model_backend: BaseModelBackend = (
             model
             if model is not None
@@ -272,11 +277,12 @@ def reset(self):
             terminator.reset()
 
     @property
-    def system_message(self) -> BaseMessage:
+    def system_message(self) -> Optional[BaseMessage]:
         r"""The getter method for the property :obj:`system_message`.
 
         Returns:
-            BaseMessage: The system message of this agent.
+            Optional[BaseMessage]: The system message of this agent if set,
+                else :obj:`None`.
         """
         return self._system_message
 
@@ -327,12 +333,22 @@ def set_output_language(self, output_language: str) -> BaseMessage:
             BaseMessage: The updated system message object.
         """
         self.output_language = output_language
-        content = self.orig_sys_message.content + (
+        language_prompt = (
             "\nRegardless of the input language, "
             f"you must output text in {output_language}."
         )
-        self.system_message = self.system_message.create_new_instance(content)
-        return self.system_message
+        if self.orig_sys_message is not None:
+            content = self.orig_sys_message.content + language_prompt
+            self._system_message = self.orig_sys_message.create_new_instance(
+                content
+            )
+            return self._system_message
+        else:
+            self._system_message = BaseMessage.make_assistant_message(
+                role_name="Assistant",
+                content=language_prompt,
+            )
+            return self._system_message
 
     def get_info(
         self,
@@ -377,12 +393,15 @@ def init_messages(self) -> None:
         r"""Initializes the stored messages list with the initial system
         message.
         """
-        system_record = MemoryRecord(
-            message=self.system_message,
-            role_at_backend=OpenAIBackendRole.SYSTEM,
-        )
-        self.memory.clear()
-        self.memory.write_record(system_record)
+        if self.orig_sys_message is not None:
+            system_record = MemoryRecord(
+                message=self.orig_sys_message,
+                role_at_backend=OpenAIBackendRole.SYSTEM,
+            )
+            self.memory.clear()
+            self.memory.write_record(system_record)
+        else:
+            self.memory.clear()
 
     def record_message(self, message: BaseMessage) -> None:
         r"""Records the externally provided message into the agent memory as if
@@ -795,12 +814,12 @@ def _structure_output_with_function(
         r"""Internal function of structuring the output of the agent based on
         the given output schema.
         """
-        from camel.toolkits import OpenAIFunction
+        from camel.toolkits import FunctionTool
 
         schema_json = get_pydantic_object_schema(output_schema)
         func_str = json_to_function_code(schema_json)
         func_callable = func_string_to_callable(func_str)
-        func = OpenAIFunction(func_callable)
+        func = FunctionTool(func_callable)
 
         original_func_dict = self.func_dict
         original_model_dict = self.model_backend.model_config_dict

camel/configs/base_config.py

@@ -39,13 +39,13 @@ class BaseConfig(ABC, BaseModel):
     @classmethod
     def fields_type_checking(cls, tools):
         if tools is not None:
-            from camel.toolkits import OpenAIFunction
+            from camel.toolkits import FunctionTool
 
             for tool in tools:
-                if not isinstance(tool, OpenAIFunction):
+                if not isinstance(tool, FunctionTool):
                     raise ValueError(
                         f"The tool {tool} should "
-                        "be an instance of `OpenAIFunction`."
+                        "be an instance of `FunctionTool`."
                     )
         return tools
 
@@ -54,14 +54,14 @@ def as_dict(self) -> dict[str, Any]:
 
         tools_schema = None
         if self.tools:
-            from camel.toolkits import OpenAIFunction
+            from camel.toolkits import FunctionTool
 
             tools_schema = []
             for tool in self.tools:
-                if not isinstance(tool, OpenAIFunction):
+                if not isinstance(tool, FunctionTool):
                     raise ValueError(
                         f"The tool {tool} should "
-                        "be an instance of `OpenAIFunction`."
+                        "be an instance of `FunctionTool`."
                     )
                 tools_schema.append(tool.get_openai_tool_schema())
         config_dict["tools"] = tools_schema

camel/configs/groq_config.py

@@ -73,7 +73,7 @@ class GroqConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/openai_config.py

@@ -81,7 +81,7 @@ class ChatGPTConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/samba_config.py

@@ -172,7 +172,7 @@ class SambaCloudAPIConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/zhipuai_config.py

@@ -45,7 +45,7 @@ class ZhipuAIConfig(BaseConfig):
             in the chat completion. The total length of input tokens and
             generated tokens is limited by the model's context length.
             (default: :obj:`None`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/messages/__init__.py

@@ -32,6 +32,7 @@
     'OpenAISystemMessage',
     'OpenAIAssistantMessage',
     'OpenAIUserMessage',
+    'OpenAIFunctionMessage',
     'OpenAIMessage',
     'BaseMessage',
     'FunctionCallingMessage',

camel/societies/babyagi_playing.py

@@ -106,7 +106,7 @@ def __init__(
         )
 
         self.assistant_agent: ChatAgent
-        self.assistant_sys_msg: BaseMessage
+        self.assistant_sys_msg: Optional[BaseMessage]
         self.task_creation_agent: TaskCreationAgent
         self.task_prioritization_agent: TaskPrioritizationAgent
         self.init_agents(
@@ -202,7 +202,8 @@ def init_agents(
 
         self.task_creation_agent = TaskCreationAgent(
             objective=self.specified_task_prompt,
-            role_name=self.assistant_sys_msg.role_name,
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
             output_language=output_language,
             message_window_size=message_window_size,
             **(task_creation_agent_kwargs or {}),
@@ -238,7 +239,9 @@ def step(self) -> ChatAgentResponse:
 
         task_name = self.subtasks.popleft()
         assistant_msg_msg = BaseMessage.make_user_message(
-            role_name=self.assistant_sys_msg.role_name, content=f"{task_name}"
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
+            content=f"{task_name}",
         )
 
         assistant_response = self.assistant_agent.step(assistant_msg_msg)

camel/societies/role_playing.py

@@ -149,8 +149,8 @@ def __init__(
 
         self.assistant_agent: ChatAgent
         self.user_agent: ChatAgent
-        self.assistant_sys_msg: BaseMessage
-        self.user_sys_msg: BaseMessage
+        self.assistant_sys_msg: Optional[BaseMessage]
+        self.user_sys_msg: Optional[BaseMessage]
         self._init_agents(
             init_assistant_sys_msg,
             init_user_sys_msg,
@@ -454,9 +454,11 @@ def init_chat(self, init_msg_content: Optional[str] = None) -> BaseMessage:
         )
         if init_msg_content is None:
             init_msg_content = default_init_msg_content
+
         # Initialize a message sent by the assistant
         init_msg = BaseMessage.make_assistant_message(
-            role_name=self.assistant_sys_msg.role_name,
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
             content=init_msg_content,
         )