camel-ai 0.2.3a1__py3-none-any.whl → 0.2.4__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.2.2'
+__version__ = '0.2.4'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -34,7 +34,6 @@ from openai.types.chat.chat_completion_message_tool_call import Function
 from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
-from camel.configs import ChatGPTConfig
 from camel.memories import (
     AgentMemory,
     ChatHistoryMemory,
@@ -63,7 +62,7 @@ if TYPE_CHECKING:
     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 +114,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 (Union[BaseMessage, str], 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 +131,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,34 +144,42 @@ class ChatAgent(BaseAgent):
 
     def __init__(
         self,
-        system_message: BaseMessage,
+        system_message: Optional[Union[BaseMessage, str]] = 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
+        if isinstance(system_message, str):
+            system_message = BaseMessage.make_assistant_message(
+                role_name='Assistant', content=system_message
+            )
+
+        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
             else ModelFactory.create(
-                model_platform=ModelPlatformType.OPENAI,
-                model_type=ModelType.GPT_4O_MINI,
-                model_config_dict=ChatGPTConfig().as_dict(),
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
             )
         )
         self.output_language: Optional[str] = output_language
         if self.output_language is not None:
             self.set_output_language(self.output_language)
 
-        self.model_type: ModelType = self.model_backend.model_type
+        self.model_type = self.model_backend.model_type
 
         # tool registration
         external_tools = external_tools or []
@@ -272,11 +280,12 @@ class ChatAgent(BaseAgent):
             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 +336,22 @@ class ChatAgent(BaseAgent):
             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 +396,15 @@ class ChatAgent(BaseAgent):
         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
@@ -397,19 +419,19 @@ class ChatAgent(BaseAgent):
 
     def step(
         self,
-        input_message: BaseMessage,
-        output_schema: Optional[Type[BaseModel]] = None,
+        input_message: Union[BaseMessage, str],
+        response_format: Optional[Type[BaseModel]] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message.
 
         Args:
-            input_message (BaseMessage): The input message to the agent.
-                Its `role` field that specifies the role at backend may be
-                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[Type[BaseModel]], optional): A pydantic
+            input_message (Union[BaseMessage, str]): The input message to the
+                agent. For BaseMessage input, its `role` field that specifies
+                the role at backend may be either `user` or `assistant` but it
+                will be set to `user` anyway since for the self agent any
+                incoming message is external. For str input, the `role_name` would be `User`.
+            response_format (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:
@@ -420,12 +442,12 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
-        if (
-            isinstance(self.model_type, ModelType)
-            and "lama" in self.model_type.value
-            or isinstance(self.model_type, str)
-            and "lama" in self.model_type
-        ):
+        if isinstance(input_message, str):
+            input_message = BaseMessage.make_user_message(
+                role_name='User', content=input_message
+            )
+
+        if "llama" in self.model_type.lower():
             if self.model_backend.model_config_dict.get("tools", None):
                 tool_prompt = self._generate_tool_prompt(self.tool_schema_list)
 
@@ -506,10 +528,7 @@ class ChatAgent(BaseAgent):
                     self._step_tool_call_and_update(response)
                 )
 
-            if (
-                output_schema is not None
-                and self.model_type.supports_tool_calling
-            ):
+            if response_format is not None:
                 (
                     output_messages,
                     finish_reasons,
@@ -517,7 +536,7 @@ class ChatAgent(BaseAgent):
                     response_id,
                     tool_call,
                     num_tokens,
-                ) = self._structure_output_with_function(output_schema)
+                ) = self._structure_output_with_function(response_format)
                 tool_call_records.append(tool_call)
 
             info = self._step_get_info(
@@ -599,8 +618,8 @@ class ChatAgent(BaseAgent):
                 )
 
             if (
-                output_schema is not None
-                and self.model_type.supports_tool_calling
+                response_format is not None
+                and self.model_type.support_native_tool_calling
             ):
                 (
                     output_messages,
@@ -609,7 +628,7 @@ class ChatAgent(BaseAgent):
                     response_id,
                     tool_call,
                     num_tokens,
-                ) = self._structure_output_with_function(output_schema)
+                ) = self._structure_output_with_function(response_format)
                 tool_call_records.append(tool_call)
 
             info = self._step_get_info(
@@ -637,19 +656,19 @@ class ChatAgent(BaseAgent):
 
     async def step_async(
         self,
-        input_message: BaseMessage,
-        output_schema: Optional[Type[BaseModel]] = None,
+        input_message: Union[BaseMessage, str],
+        response_format: 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.
 
         Args:
-            input_message (BaseMessage): The input message to the agent.
-                Its `role` field that specifies the role at backend may be
-                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[Type[BaseModel]], optional): A pydantic
+            input_message (Union[BaseMessage, str]): The input message to the
+                agent. For BaseMessage input, its `role` field that specifies
+                the role at backend may be either `user` or `assistant` but it
+                will be set to `user` anyway since for the self agent any
+                incoming message is external. For str input, the `role_name` would be `User`.
+            response_format (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:
@@ -660,6 +679,11 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
+        if isinstance(input_message, str):
+            input_message = BaseMessage.make_user_message(
+                role_name='User', content=input_message
+            )
+
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
         tool_call_records: List[FunctionCallingRecord] = []
@@ -708,7 +732,10 @@ class ChatAgent(BaseAgent):
                 await self._step_tool_call_and_update_async(response)
             )
 
-        if output_schema is not None and self.model_type.supports_tool_calling:
+        if (
+            response_format is not None
+            and self.model_type.support_native_tool_calling
+        ):
             (
                 output_messages,
                 finish_reasons,
@@ -716,7 +743,7 @@ class ChatAgent(BaseAgent):
                 response_id,
                 tool_call_record,
                 num_tokens,
-            ) = self._structure_output_with_function(output_schema)
+            ) = self._structure_output_with_function(response_format)
             tool_call_records.append(tool_call_record)
 
         info = self._step_get_info(
@@ -783,7 +810,7 @@ class ChatAgent(BaseAgent):
         return func_record
 
     def _structure_output_with_function(
-        self, output_schema: Type[BaseModel]
+        self, response_format: Type[BaseModel]
     ) -> Tuple[
         List[BaseMessage],
         List[str],
@@ -795,12 +822,12 @@ class ChatAgent(BaseAgent):
         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)
+        schema_json = get_pydantic_object_schema(response_format)
         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
@@ -1174,10 +1201,7 @@ class ChatAgent(BaseAgent):
         Returns:
             dict: Usage dictionary.
         """
-        if isinstance(self.model_type, ModelType):
-            encoding = get_model_encoding(self.model_type.value_for_tiktoken)
-        else:
-            encoding = get_model_encoding("gpt-4o-mini")
+        encoding = get_model_encoding(self.model_type.value_for_tiktoken)
         completion_tokens = 0
         for message in output_messages:
             completion_tokens += len(encoding.encode(message.content))

camel/agents/knowledge_graph_agent.py

@@ -11,12 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
-try:
+if TYPE_CHECKING:
     from unstructured.documents.elements import Element
-except ImportError:
-    Element = None
 
 from camel.agents import ChatAgent
 from camel.messages import BaseMessage
@@ -144,13 +142,13 @@ class KnowledgeGraphAgent(ChatAgent):
 
     def run(
         self,
-        element: Union[str, Element],
+        element: "Element",
         parse_graph_elements: bool = False,
     ) -> Union[str, GraphElement]:
         r"""Run the agent to extract node and relationship information.
 
         Args:
-            element (Union[str, Element]): The input element or string.
+            element (Element): The input element.
             parse_graph_elements (bool, optional): Whether to parse into
                 `GraphElement`. Defaults to `False`.
 

camel/bots/__init__.py

@@ -11,10 +11,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from .discord_bot import DiscordBot
+from .discord_app import DiscordApp
+from .slack.models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackAuthProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from .slack.slack_app import SlackApp
 from .telegram_bot import TelegramBot
 
 __all__ = [
-    'DiscordBot',
+    'DiscordApp',
+    'SlackApp',
+    'SlackAppMentionEventBody',
+    'SlackAppMentionEventProfile',
+    'SlackAuthProfile',
+    'SlackEventBody',
+    'SlackEventProfile',
     'TelegramBot',
 ]

camel/bots/discord_app.py

@@ -0,0 +1,138 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import logging
+import os
+from typing import TYPE_CHECKING, List, Optional
+
+from camel.utils import dependencies_required
+
+if TYPE_CHECKING:
+    from discord import Message
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DiscordApp:
+    r"""A class representing a Discord app that uses the `discord.py` library
+    to interact with Discord servers.
+
+    This bot can respond to messages in specific channels and only reacts to
+    messages that mention the bot.
+
+    Attributes:
+        channel_ids (Optional[List[int]]): A list of allowed channel IDs. If
+            provided, the bot will only respond to messages in these channels.
+        token (Optional[str]): The Discord bot token used for authentication.
+    """
+
+    @dependencies_required('discord')
+    def __init__(
+        self,
+        channel_ids: Optional[List[int]] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        r"""Initialize the DiscordApp instance by setting up the Discord client
+        and event handlers.
+
+        Args:
+            channel_ids (Optional[List[int]]): A list of allowed channel IDs.
+                The bot will only respond to messages in these channels if
+                provided.
+            token (Optional[str]): The Discord bot token for authentication.
+                If not provided, the token will be retrieved from the
+                environment variable `DISCORD_TOKEN`.
+
+        Raises:
+            ValueError: If the `DISCORD_TOKEN` is not found in environment
+                variables.
+        """
+        self.token = token or os.getenv('DISCORD_TOKEN')
+        self.channel_ids = channel_ids
+
+        if not self.token:
+            raise ValueError(
+                "`DISCORD_TOKEN` not found in environment variables. Get it"
+                " here: `https://discord.com/developers/applications`."
+            )
+
+        import discord
+
+        intents = discord.Intents.default()
+        intents.message_content = True
+        self._client = discord.Client(intents=intents)
+
+        # Register event handlers
+        self._client.event(self.on_ready)
+        self._client.event(self.on_message)
+
+    async def start(self):
+        r"""Asynchronously start the Discord bot using its token.
+
+        This method starts the bot and logs into Discord asynchronously using
+        the provided token. It should be awaited when used in an async
+        environment.
+        """
+        await self._client.start(self.token)
+
+    def run(self) -> None:
+        r"""Start the Discord bot using its token.
+
+        This method starts the bot and logs into Discord synchronously using
+        the provided token. It blocks execution and keeps the bot running.
+        """
+        self._client.run(self.token)  # type: ignore[arg-type]
+
+    async def on_ready(self) -> None:
+        r"""Event handler that is called when the bot has successfully
+        connected to the Discord server.
+
+        When the bot is ready and logged into Discord, it prints a message
+        displaying the bot's username.
+        """
+        logger.info(f'We have logged in as {self._client.user}')
+
+    async def on_message(self, message: 'Message') -> None:
+        r"""Event handler for processing incoming messages.
+
+        This method is called whenever a new message is received by the bot. It
+        will ignore messages sent by the bot itself, only respond to messages
+        in allowed channels (if specified), and only to messages that mention
+        the bot.
+
+        Args:
+            message (discord.Message): The message object received from
+                Discord.
+        """
+        # If the message author is the bot itself,
+        # do not respond to this message
+        if message.author == self._client.user:
+            return
+
+        # If allowed channel IDs are provided,
+        # only respond to messages in those channels
+        if self.channel_ids and message.channel.id not in self.channel_ids:
+            return
+
+        # Only respond to messages that mention the bot
+        if not self._client.user or not self._client.user.mentioned_in(
+            message
+        ):
+            return
+
+        logger.info(f"Received message: {message.content}")
+
+    @property
+    def client(self):
+        return self._client

camel/bots/slack/__init__.py

@@ -0,0 +1,30 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+from .models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackAuthProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from .slack_app import SlackApp
+
+__all__ = [
+    'SlackApp',
+    'SlackAppMentionEventBody',
+    'SlackAppMentionEventProfile',
+    'SlackAuthProfile',
+    'SlackEventBody',
+    'SlackEventProfile',
+]