camel-ai 0.1.1__py3-none-any.whl

camel/messages/func_message.py

@@ -0,0 +1,106 @@
+# =========== 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 dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from camel.messages import (
+    BaseMessage,
+    OpenAIAssistantMessage,
+    OpenAIFunctionMessage,
+    OpenAIMessage,
+)
+from camel.types import OpenAIBackendRole
+
+
+@dataclass
+class FunctionCallingMessage(BaseMessage):
+    r"""Class for message objects used specifically for
+    function-related messages.
+
+    Args:
+        func_name (Optional[str]): The name of the function used.
+            (default: :obj:`None`)
+        args (Optional[Dict]): The dictionary of arguments passed to the
+            function. (default: :obj:`None`)
+        result (Optional[Any]): The result of function execution.
+            (default: :obj:`None`)
+    """
+    func_name: Optional[str] = None
+    args: Optional[Dict] = None
+    result: Optional[Any] = None
+
+    def to_openai_message(
+        self,
+        role_at_backend: OpenAIBackendRole,
+    ) -> OpenAIMessage:
+        r"""Converts the message to an :obj:`OpenAIMessage` object.
+
+        Args:
+            role_at_backend (OpenAIBackendRole): The role of the message in
+                OpenAI chat system.
+
+        Returns:
+            OpenAIMessage: The converted :obj:`OpenAIMessage` object.
+        """
+        if role_at_backend == OpenAIBackendRole.ASSISTANT:
+            return self.to_openai_assistant_message()
+        elif role_at_backend == OpenAIBackendRole.FUNCTION:
+            return self.to_openai_function_message()
+        else:
+            raise ValueError(f"Unsupported role: {role_at_backend}.")
+
+    def to_openai_assistant_message(self) -> OpenAIAssistantMessage:
+        r"""Converts the message to an :obj:`OpenAIAssistantMessage` object.
+
+        Returns:
+            OpenAIAssistantMessage: The converted :obj:`OpenAIAssistantMessage`
+                object.
+        """
+        if (not self.func_name) or (not self.args):
+            raise ValueError(
+                "Invalid request for converting into assistant message"
+                " due to missing function name or arguments.")
+
+        msg_dict: OpenAIAssistantMessage = {
+            "role": "assistant",
+            "content": self.content,
+            "function_call": {
+                "name": self.func_name,
+                "arguments": str(self.args),
+            }
+        }
+
+        return msg_dict
+
+    def to_openai_function_message(self) -> OpenAIFunctionMessage:
+        r"""Converts the message to an :obj:`OpenAIMessage` object
+        with the role being "function".
+
+        Returns:
+            OpenAIMessage: The converted :obj:`OpenAIMessage` object
+                with its role being "function".
+        """
+        if (not self.func_name) or (not self.result):
+            raise ValueError(
+                "Invalid request for converting into function message"
+                " due to missing function name or results.")
+
+        result_content = {"result": {str(self.result)}}
+        msg_dict: OpenAIFunctionMessage = {
+            "role": "function",
+            "name": self.func_name,
+            "content": f'{result_content}',
+        }
+
+        return msg_dict

camel/models/__init__.py

@@ -0,0 +1,26 @@
+# =========== 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 .base_model import BaseModelBackend
+from .openai_model import OpenAIModel
+from .stub_model import StubModel
+from .open_source_model import OpenSourceModel
+from .model_factory import ModelFactory
+
+__all__ = [
+    'BaseModelBackend',
+    'OpenAIModel',
+    'StubModel',
+    'OpenSourceModel',
+    'ModelFactory',
+]

camel/models/base_model.py

@@ -0,0 +1,110 @@
+# =========== 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 abc import ABC, abstractmethod
+from typing import Any, Dict, List, Union
+
+from openai import Stream
+
+from camel.messages import OpenAIMessage
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import BaseTokenCounter
+
+
+class BaseModelBackend(ABC):
+    r"""Base class for different model backends.
+    May be OpenAI API, a local LLM, a stub for unit tests, etc.
+    """
+
+    def __init__(self, model_type: ModelType,
+                 model_config_dict: Dict[str, Any]) -> None:
+        r"""Constructor for the model backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A config dictionary.
+        """
+        self.model_type = model_type
+
+        self.model_config_dict = model_config_dict
+        self.check_model_config()
+
+    @property
+    @abstractmethod
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        pass
+
+    @abstractmethod
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs the query to the backend model.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        pass
+
+    @abstractmethod
+    def check_model_config(self):
+        r"""Check whether the input model configuration contains unexpected
+        arguments
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected argument for this model class.
+        """
+        pass
+
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Count the number of tokens in the messages using the specific
+        tokenizer.
+
+        Args:
+            messages (List[Dict]): message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            int: Number of tokens in the messages.
+        """
+        return self.token_counter.count_tokens_from_messages(messages)
+
+    @property
+    def token_limit(self) -> int:
+        r"""Returns the maximum token limit for a given model.
+        Returns:
+            int: The maximum token limit for the given model.
+        """
+        return self.model_type.token_limit
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode,
+            which sends partial results each time.
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return False

camel/models/model_factory.py

@@ -0,0 +1,59 @@
+# =========== 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 typing import Any, Dict
+
+from camel.models import (
+    BaseModelBackend,
+    OpenAIModel,
+    OpenSourceModel,
+    StubModel,
+)
+from camel.types import ModelType
+
+
+class ModelFactory:
+    r"""Factory of backend models.
+
+    Raises:
+        ValueError: in case the provided model type is unknown.
+    """
+
+    @staticmethod
+    def create(model_type: ModelType,
+               model_config_dict: Dict) -> BaseModelBackend:
+        r"""Creates an instance of `BaseModelBackend` of the specified type.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created.
+            model_config_dict (Dict): A dictionary that will be fed into
+                the backend constructor.
+
+        Raises:
+            ValueError: If there is not backend for the model.
+
+        Returns:
+            BaseModelBackend: The initialized backend.
+        """
+        model_class: Any
+        if model_type.is_openai:
+            model_class = OpenAIModel
+        elif model_type == ModelType.STUB:
+            model_class = StubModel
+        elif model_type.is_open_source:
+            model_class = OpenSourceModel
+        else:
+            raise ValueError(f"Unknown model type `{model_type}` is input")
+
+        inst = model_class(model_type, model_config_dict)
+        return inst

camel/models/open_source_model.py

@@ -0,0 +1,144 @@
+# =========== 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 typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import OPENAI_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import BaseTokenCounter, OpenSourceTokenCounter
+
+
+class OpenSourceModel(BaseModelBackend):
+    r"""Class for interace with OpenAI-API-compatible servers running
+    open-source models.
+    """
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+    ) -> None:
+        r"""Constructor for model backends of Open-source models.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into :obj:`openai.ChatCompletion.create()`.
+        """
+        super().__init__(model_type, model_config_dict)
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+        # Check whether the input model type is open-source
+        if not model_type.is_open_source:
+            raise ValueError(
+                f"Model `{model_type}` is not a supported open-source model.")
+
+        # Check whether input model path is empty
+        model_path: Optional[str] = (self.model_config_dict.get(
+            "model_path", None))
+        if not model_path:
+            raise ValueError("Path to open-source model is not provided.")
+        self.model_path: str = model_path
+
+        # Check whether the model name matches the model type
+        self.model_name: str = self.model_path.split('/')[-1]
+        if not self.model_type.validate_model_name(self.model_name):
+            raise ValueError(
+                f"Model name `{self.model_name}` does not match model type "
+                f"`{self.model_type.value}`.")
+
+        # Load the server URL and check whether it is None
+        server_url: Optional[str] = (self.model_config_dict.get(
+            "server_url", None))
+        if not server_url:
+            raise ValueError(
+                "URL to server running open-source LLM is not provided.")
+        self.server_url: str = server_url
+        self._client = OpenAI(
+            base_url=self.server_url,
+            timeout=60,
+            max_retries=3,
+        )
+
+        # Replace `model_config_dict` with only the params to be
+        # passed to OpenAI API
+        self.model_config_dict = self.model_config_dict["api_params"].__dict__
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenSourceTokenCounter(
+                self.model_type, self.model_path)
+        return self._token_counter
+
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI-API-style chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        messages_openai: List[OpenAIMessage] = messages
+        response = self._client.chat.completions.create(
+            messages=messages_openai,
+            model=self.model_name,
+            **self.model_config_dict,
+        )
+        return response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration is valid for open-source
+        model backends.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API, or it does not contain
+                :obj:`model_path` or :obj:`server_url`.
+        """
+        if ("model_path" not in self.model_config_dict
+                or "server_url" not in self.model_config_dict):
+            raise ValueError(
+                "Invalid configuration for open-source model backend with "
+                ":obj:`model_path` or :obj:`server_url` missing.")
+
+        for param in self.model_config_dict["api_params"].__dict__:
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(f"Unexpected argument `{param}` is "
+                                 "input into open-source model backend.")
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode,
+            which sends partial results each time.
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/openai_model.py

@@ -0,0 +1,103 @@
+# =========== 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 os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import OPENAI_API_PARAMS_WITH_FUNCTIONS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    openai_api_key_required,
+)
+
+
+class OpenAIModel(BaseModelBackend):
+    r"""OpenAI API in a unified BaseModelBackend interface."""
+
+    def __init__(self, model_type: ModelType,
+                 model_config_dict: Dict[str, Any]) -> None:
+        r"""Constructor for OpenAI backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                one of GPT_* series.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into openai.ChatCompletion.create().
+        """
+        super().__init__(model_type, model_config_dict)
+        url = os.environ.get('OPENAI_API_BASE_URL', None)
+        self._client = OpenAI(timeout=60, max_retries=3, base_url=url)
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(self.model_type)
+        return self._token_counter
+
+    @openai_api_key_required
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type.value,
+            **self.model_config_dict,
+        )
+        return response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to OpenAI API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in OPENAI_API_PARAMS_WITH_FUNCTIONS:
+                raise ValueError(f"Unexpected argument `{param}` is "
+                                 "input into OpenAI model backend.")
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode,
+            which sends partial results each time.
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/stub_model.py

@@ -0,0 +1,106 @@
+# =========== 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 time
+from typing import Any, Dict, List, Optional, Union
+
+from openai import Stream
+
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ChatCompletionMessage,
+    Choice,
+    CompletionUsage,
+    ModelType,
+)
+from camel.utils import BaseTokenCounter
+
+
+class StubTokenCounter(BaseTokenCounter):
+
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Token counting for STUB models, directly returning a constant.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            int: A constant to act as the number of the tokens in the
+                messages.
+        """
+        return 10
+
+
+class StubModel(BaseModelBackend):
+    r"""A dummy model used for unit tests."""
+    model_type = ModelType.STUB
+
+    def __init__(self, model_type: ModelType,
+                 model_config_dict: Dict[str, Any]) -> None:
+        r"""All arguments are unused for the dummy model."""
+        super().__init__(model_type, model_config_dict)
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = StubTokenCounter()
+        return self._token_counter
+
+    def run(
+        self, messages: List[OpenAIMessage]
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Run fake inference by returning a fixed string.
+        All arguments are unused for the dummy model.
+
+        Returns:
+            Dict[str, Any]: Response in the OpenAI API format.
+        """
+        ARBITRARY_STRING = "Lorem Ipsum"
+        response: ChatCompletion = ChatCompletion(
+            id="stub_model_id",
+            model="stub",
+            object="chat.completion",
+            created=int(time.time()),
+            choices=[
+                Choice(
+                    finish_reason="stop",
+                    index=0,
+                    message=ChatCompletionMessage(
+                        content=ARBITRARY_STRING,
+                        role="assistant",
+                    ),
+                )
+            ],
+            usage=CompletionUsage(
+                completion_tokens=10,
+                prompt_tokens=10,
+                total_tokens=20,
+            ),
+        )
+        return response
+
+    def check_model_config(self):
+        r"""Directly pass the check on arguments to STUB model.
+        """
+        pass