camel-ai 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

camel/bots/discord/discord_app.py

@@ -0,0 +1,384 @@
+# ========= 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 datetime import datetime, timedelta
+from typing import TYPE_CHECKING, List, Optional
+
+import discord
+import httpx
+from fastapi import FastAPI
+
+from camel.bots.discord.discord_installation import DiscordInstallation
+from camel.logger import get_logger
+from camel.utils import api_keys_required, dependencies_required
+
+from .discord_store import DiscordBaseInstallationStore
+
+if TYPE_CHECKING:
+    from discord import Message
+
+logger = get_logger(__name__)
+
+TOKEN_URL = "https://discord.com/api/oauth2/token"
+USER_URL = "https://discord.com/api/users/@me"
+
+
+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')
+    @api_keys_required(
+        [
+            ("token", "DISCORD_BOT_TOKEN"),
+        ]
+    )
+    def __init__(
+        self,
+        channel_ids: Optional[List[int]] = None,
+        token: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        redirect_uri: Optional[str] = None,
+        installation_store: Optional[DiscordBaseInstallationStore] = None,
+        intents: Optional[discord.Intents] = 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. (default: :obj:`None`)
+            token (Optional[str]): The Discord bot token for authentication.
+                If not provided, the token will be retrieved from the
+                environment variable `DISCORD_TOKEN`. (default: :obj:`None`)
+            client_id (str, optional): The client ID for Discord OAuth.
+                (default: :obj:`None`)
+            client_secret (Optional[str]): The client secret for Discord OAuth.
+                (default: :obj:`None`)
+            redirect_uri (str): The redirect URI for OAuth callbacks.
+                (default: :obj:`None`)
+            installation_store (DiscordAsyncInstallationStore): The database
+                stores all information of all installations.
+                (default: :obj:`None`)
+            intents (discord.Intents): The Discord intents of this app.
+                (default: :obj:`None`)
+
+        Raises:
+            ValueError: If the `DISCORD_BOT_TOKEN` is not found in environment
+                variables.
+        """
+        self.token = token or os.getenv("DISCORD_BOT_TOKEN")
+        self.channel_ids = channel_ids
+        self.installation_store = installation_store
+
+        if not intents:
+            intents = discord.Intents.all()
+            intents.message_content = True
+            intents.guilds = True
+
+        self._client = discord.Client(intents=intents)
+
+        # Register event handlers
+        self._client.event(self.on_ready)
+        self._client.event(self.on_message)
+
+        # OAuth flow
+        self.client_id = client_id or os.getenv("DISCORD_CLIENT_ID")
+        self.client_secret = client_secret or os.getenv(
+            "DISCORD_CLIENT_SECRET"
+        )
+        self.redirect_uri = redirect_uri
+
+        self.oauth_flow = bool(
+            self.client_id
+            and self.client_secret
+            and self.redirect_uri
+            and self.installation_store
+        )
+
+        self.app = FastAPI()
+
+    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 exchange_code_for_token_response(
+        self, code: str
+    ) -> Optional[str]:
+        r"""Exchange the authorization code for an access token.
+
+        Args:
+            code (str): The authorization code received from Discord after
+                user authorization.
+
+        Returns:
+            Optional[str]: The access token if successful, otherwise None.
+
+        Raises:
+            ValueError: If OAuth configuration is incomplete or invalid.
+            httpx.RequestError: If there is a network issue during the request.
+        """
+        if not self.oauth_flow:
+            logger.warning(
+                "OAuth is not enabled. Missing client_id, "
+                "client_secret, or redirect_uri."
+            )
+            return None
+        data = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": self.redirect_uri,
+        }
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    TOKEN_URL, data=data, headers=headers
+                )
+                if response.status_code != 200:
+                    logger.error(f"Failed to exchange code: {response.text}")
+                    return None
+                response_data = response.json()
+
+                return response_data
+        except (httpx.RequestError, ValueError) as e:
+            logger.error(f"Error during token fetch: {e}")
+            return None
+
+    async def get_user_info(self, access_token: str) -> Optional[dict]:
+        r"""Retrieve user information using the access token.
+
+        Args:
+            access_token (str): The access token received from Discord.
+
+        Returns:
+            dict: The user information retrieved from Discord.
+        """
+        if not self.oauth_flow:
+            logger.warning(
+                "OAuth is not enabled. Missing client_id, "
+                "client_secret, or redirect_uri."
+            )
+            return None
+        headers = {"Authorization": f"Bearer {access_token}"}
+        async with httpx.AsyncClient() as client:
+            user_response = await client.get(USER_URL, headers=headers)
+            return user_response.json()
+
+    async def refresh_access_token(self, refresh_token: str) -> Optional[str]:
+        r"""Refresh the access token using a refresh token.
+
+        Args:
+            refresh_token (str): The refresh token issued by Discord that
+                can be used to obtain a new access token.
+
+        Returns:
+            Optional[str]: The new access token if successful, otherwise None.
+        """
+        if not self.oauth_flow:
+            logger.warning(
+                "OAuth is not enabled. Missing client_id, "
+                "client_secret, or redirect_uri."
+            )
+            return None
+        data = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "redirect_uri": self.redirect_uri,
+        }
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        async with httpx.AsyncClient() as client:
+            response = await client.post(TOKEN_URL, data=data, headers=headers)
+            if response.status_code != 200:
+                logger.error(f"Failed to refresh token: {response.text}")
+                return None
+            response_data = response.json()
+            return response_data.get("access_token")
+
+    async def get_valid_access_token(self, guild_id: str) -> Optional[str]:
+        r"""Retrieve a valid access token for the specified guild.
+
+        This method attempts to retrieve an access token for a specific guild.
+        If the current access token is expired, it will refresh the token using
+        the refresh token.
+
+        Args:
+            guild_id (str): The ID of the guild to retrieve the access
+                token for.
+
+        Returns:
+            Optional[str]: The valid access token if successful,
+                otherwise None.
+        """
+        if not self.oauth_flow:
+            logger.warning(
+                "OAuth is not enabled. Missing client_id, "
+                "client_secret, or redirect_uri."
+            )
+            return None
+        assert self.installation_store is not None
+        installation = await self.installation_store.find_by_guild(
+            guild_id=guild_id
+        )
+        if not installation:
+            logger.error(f"No installation found for guild: {guild_id}")
+            return None
+
+        if (
+            installation.token_expires_at
+            and datetime.now() >= installation.token_expires_at
+        ):
+            logger.info(
+                f"Access token expired for guild: {guild_id}, "
+                f"refreshing token..."
+            )
+            new_access_token = await self.refresh_access_token(
+                installation.refresh_token
+            )
+            if new_access_token:
+                installation.access_token = new_access_token
+                installation.token_expires_at = datetime.now() + timedelta(
+                    seconds=3600
+                )
+                await self.installation_store.save(installation)
+                return new_access_token
+            else:
+                logger.error(
+                    f"Failed to refresh access token for guild: {guild_id}"
+                )
+                return None
+
+        return installation.access_token
+
+    async def save_installation(
+        self,
+        guild_id: str,
+        access_token: str,
+        refresh_token: str,
+        expires_in: int,
+    ):
+        r"""Save the installation information for a given guild.
+
+        Args:
+            guild_id (str): The ID of the guild where the bot is installed.
+            access_token (str): The access token for the guild.
+            refresh_token (str): The refresh token for the guild.
+            expires_in: (int): The expiration time of the
+                access token.
+        """
+        if not self.oauth_flow:
+            logger.warning(
+                "OAuth is not enabled. Missing client_id, "
+                "client_secret, or redirect_uri."
+            )
+            return None
+        assert self.installation_store is not None
+        expires_at = datetime.now() + timedelta(seconds=expires_in)
+        installation = DiscordInstallation(
+            guild_id=guild_id,
+            access_token=access_token,
+            refresh_token=refresh_token,
+            installed_at=datetime.now(),
+            token_expires_at=expires_at,
+        )
+        await self.installation_store.save(installation)
+        logger.info(f"Installation saved for guild: {guild_id}")
+
+    async def remove_installation(self, guild: discord.Guild):
+        r"""Remove the installation for a given guild.
+
+        Args:
+            guild (discord.Guild): The guild from which the bot is
+                being removed.
+        """
+        if not self.oauth_flow:
+            logger.warning(
+                "OAuth is not enabled. Missing client_id, "
+                "client_secret, or redirect_uri."
+            )
+            return None
+        assert self.installation_store is not None
+        await self.installation_store.delete(guild_id=str(guild.id))
+        print(f"Bot removed from guild: {guild.id}")
+
+    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/discord/discord_installation.py

@@ -0,0 +1,64 @@
+# ========= 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 datetime import datetime
+from typing import Optional
+
+
+class DiscordInstallation:
+    r"""Represents an installation of a Discord application in a
+        specific guild (server).
+
+    Attributes:
+        guild_id (str): The unique identifier for the Discord guild (server)
+            where the application is installed.
+        access_token (str): The access token used to authenticate API requests
+            for the installed application.
+        refresh_token (str): The token used to refresh the access token when
+            it expires.
+        installed_at (datetime): The timestamp indicating when the application
+            was installed in the guild.
+        token_expires_at (Optional[datetime]): The optional timestamp
+            indicating when the access token will expire. Defaults to None
+            if the token does not have an expiration time.
+    """
+
+    def __init__(
+        self,
+        guild_id: str,
+        access_token: str,
+        refresh_token: str,
+        installed_at: datetime,
+        token_expires_at: Optional[datetime] = None,
+    ):
+        r"""Initialize the DiscordInstallation.
+
+        Args:
+            guild_id (str): The unique identifier for the Discord guild
+                (server) where the application is installed.
+            access_token (str): The access token used to authenticate API
+                requests for the installed application.
+            refresh_token (str): The token used to refresh the access token
+                when it expires.
+            installed_at (datetime): The timestamp indicating when the
+                application was installed in the guild.
+            token_expires_at (Optional[datetime]): The optional timestamp
+                indicating when the access token will expire. Defaults to None
+                if the token does not have an expiration time.
+                (default: :obj:`None`)
+        """
+        self.guild_id = guild_id
+        self.access_token = access_token
+        self.refresh_token = refresh_token
+        self.installed_at = installed_at
+        self.token_expires_at = token_expires_at

camel/bots/discord/discord_store.py

@@ -0,0 +1,160 @@
+# ========= 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 Optional
+
+from .discord_installation import DiscordInstallation
+
+
+class DiscordBaseInstallationStore:
+    r"""Abstract base class for managing Discord installations.
+
+    This class defines the interface for database operations related to storing
+    and retrieving Discord installation data. Subclasses must implement these
+    methods to handle database-specific logic.
+    """
+
+    async def init(self):
+        r"""Initializes the database connection or structure."""
+        pass
+
+    async def save(self, installation: DiscordInstallation):
+        r"""Saves or updates a Discord installation record."""
+        pass
+
+    async def find_by_guild(
+        self, guild_id: str
+    ) -> Optional[DiscordInstallation]:
+        r"""Finds an installation record by guild ID."""
+        pass
+
+    async def delete(self, guild_id: str):
+        r"""Deletes an installation record by guild ID."""
+        pass
+
+
+class DiscordSQLiteInstallationStore(DiscordBaseInstallationStore):
+    r"""SQLite-based implementation for managing Discord installations.
+
+    This class provides methods for initializing the database, saving,
+    retrieving, and deleting installation records using SQLite.
+
+    Attributes:
+        database (str): Path to the SQLite database file.
+    """
+
+    def __init__(self, database: str):
+        r"""Initializes the SQLite installation store.
+
+        Args:
+            database (str): Path to the SQLite database file.
+        """
+        self.database = database
+
+    async def init(self):
+        r"""Initializes the database by creating the required table if it
+        does not exist."""
+        import aiosqlite
+
+        async with aiosqlite.connect(self.database) as db:
+            await db.execute(
+                """
+                CREATE TABLE IF NOT EXISTS discord_installations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    guild_id TEXT NOT NULL UNIQUE,
+                    access_token TEXT NOT NULL,
+                    refresh_token TEXT NOT NULL,
+                    installed_at DATETIME NOT NULL,
+                    token_expires_at DATETIME
+                );
+                """
+            )
+            await db.commit()
+
+    async def save(self, installation: DiscordInstallation):
+        r"""Saves a new installation record or updates an existing one.
+
+        Args:
+            installation (DiscordInstallation): The installation data to save.
+        """
+        import aiosqlite
+
+        async with aiosqlite.connect(self.database) as db:
+            await db.execute(
+                """
+                INSERT INTO discord_installations (
+                    guild_id, access_token, refresh_token, 
+                    installed_at, token_expires_at
+                ) VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(guild_id) DO UPDATE SET
+                    access_token = excluded.access_token,
+                    refresh_token = excluded.refresh_token,
+                    token_expires_at = excluded.token_expires_at;
+                """,
+                [
+                    installation.guild_id,
+                    installation.access_token,
+                    installation.refresh_token,
+                    installation.installed_at,
+                    installation.token_expires_at,
+                ],
+            )
+            await db.commit()
+
+    async def find_by_guild(
+        self, guild_id: str
+    ) -> Optional[DiscordInstallation]:
+        r"""Finds an installation record by guild ID.
+
+        Args:
+            guild_id (str): The guild ID to search for.
+
+        Returns:
+            Optional[DiscordInstallation]: The installation record if found,
+                otherwise None.
+        """
+        import aiosqlite
+
+        async with aiosqlite.connect(self.database) as db:
+            async with db.execute(
+                "SELECT guild_id, access_token, refresh_token, "
+                "installed_at, token_expires_at FROM discord_installations "
+                "WHERE guild_id = ?",
+                [guild_id],
+            ) as cursor:
+                row = await cursor.fetchone()
+                if row:
+                    return DiscordInstallation(
+                        guild_id=row[0],
+                        access_token=row[1],
+                        refresh_token=row[2],
+                        installed_at=row[3],
+                        token_expires_at=row[4],
+                    )
+                return None
+
+    async def delete(self, guild_id: str):
+        r"""Deletes an installation record by guild ID.
+
+        Args:
+            guild_id (str): The guild ID of the record to delete.
+        """
+        import aiosqlite
+
+        async with aiosqlite.connect(self.database) as db:
+            await db.execute(
+                "DELETE FROM discord_installations WHERE guild_id = ?",
+                [guild_id],
+            )
+            await db.commit()

camel/configs/__init__.py

@@ -17,6 +17,7 @@ from .cohere_config import COHERE_API_PARAMS, CohereConfig
 from .deepseek_config import DEEPSEEK_API_PARAMS, DeepSeekConfig
 from .gemini_config import Gemini_API_PARAMS, GeminiConfig
 from .groq_config import GROQ_API_PARAMS, GroqConfig
+from .internlm_config import INTERNLM_API_PARAMS, InternLMConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
@@ -76,4 +77,6 @@ __all__ = [
     'QWEN_API_PARAMS',
     'DeepSeekConfig',
     'DEEPSEEK_API_PARAMS',
+    'InternLMConfig',
+    'INTERNLM_API_PARAMS',
 ]

camel/configs/anthropic_config.py

@@ -13,10 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import List, Union
+from typing import Any, ClassVar, List, Union
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
+from camel.types import NotGiven
 
 
 class AnthropicConfig(BaseConfig):
@@ -29,41 +29,43 @@ class AnthropicConfig(BaseConfig):
             generate before stopping. Note that Anthropic models may stop
             before reaching this maximum. This parameter only specifies the
             absolute maximum number of tokens to generate.
-            (default: :obj:`256`)
+            (default: :obj:`8192`)
         stop_sequences (List[str], optional): Sequences that will cause the
             model to stop generating completion text. Anthropic models stop
             on "\n\nHuman:", and may include additional built-in stop sequences
             in the future. By providing the stop_sequences parameter, you may
             include additional strings that will cause the model to stop
-            generating.
+            generating. (default: :obj:`[]`)
         temperature (float, optional): Amount of randomness injected into the
             response. Defaults to 1. Ranges from 0 to 1. Use temp closer to 0
             for analytical / multiple choice, and closer to 1 for creative
-            and generative tasks.
-            (default: :obj:`1`)
+            and generative tasks. (default: :obj:`1`)
         top_p (float, optional): Use nucleus sampling. In nucleus sampling, we
             compute the cumulative distribution over all the options for each
             subsequent token in decreasing probability order and cut it off
             once it reaches a particular probability specified by `top_p`.
             You should either alter `temperature` or `top_p`,
-            but not both.
-            (default: :obj:`0.7`)
+            but not both. (default: :obj:`0.7`)
         top_k (int, optional): Only sample from the top K options for each
             subsequent token. Used to remove "long tail" low probability
-            responses.
-            (default: :obj:`5`)
+            responses. (default: :obj:`5`)
         metadata: An object describing metadata about the request.
         stream (bool, optional): Whether to incrementally stream the response
             using server-sent events. (default: :obj:`False`)
     """
 
-    max_tokens: int = 256
-    stop_sequences: Union[List[str], NotGiven] = NOT_GIVEN
+    max_tokens: int = 8192
+    stop_sequences: ClassVar[Union[List[str], NotGiven]] = []
     temperature: float = 1
-    top_p: Union[float, NotGiven] = NOT_GIVEN
-    top_k: Union[int, NotGiven] = NOT_GIVEN
-    metadata: NotGiven = NOT_GIVEN
+    top_p: Union[float, NotGiven] = 0.7
+    top_k: Union[int, NotGiven] = 5
     stream: bool = False
 
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = super().as_dict()
+        if "tools" in config_dict:
+            del config_dict["tools"]  # TODO: Support tool calling.
+        return config_dict
+
 
 ANTHROPIC_API_PARAMS = {param for param in AnthropicConfig.model_fields.keys()}