camel-ai 0.1.9__py3-none-any.whl → 0.2.3__py3-none-any.whl

camel/loaders/unstructured_io.py

@@ -14,6 +14,8 @@
 import uuid
 import warnings
 from typing import (
+    IO,
+    TYPE_CHECKING,
     Any,
     Dict,
     List,
@@ -23,7 +25,8 @@ from typing import (
     Union,
 )
 
-from unstructured.documents.elements import Element
+if TYPE_CHECKING:
+    from unstructured.documents.elements import Element
 
 
 class UnstructuredIO:
@@ -39,33 +42,34 @@ class UnstructuredIO:
     @staticmethod
     def create_element_from_text(
         text: str,
-        element_id: Optional[Union[str, uuid.UUID]] = None,
+        element_id: Optional[str] = None,
         embeddings: Optional[List[float]] = None,
         filename: Optional[str] = None,
         file_directory: Optional[str] = None,
         last_modified: Optional[str] = None,
         filetype: Optional[str] = None,
-        parent_id: Optional[Union[str, uuid.UUID]] = None,
-    ) -> Element:
+        parent_id: Optional[str] = None,
+    ) -> "Element":
         r"""Creates a Text element from a given text input, with optional
         metadata and embeddings.
 
         Args:
             text (str): The text content for the element.
-            element_id (Optional[Union[str, uuid.UUID]], optional): Unique
-                identifier for the element. Defaults to `None`.
-            embeddings (Optional[List[float]], optional): A list of float
-                numbers representing the text embeddings. Defaults to `None`.
+            element_id (Optional[str], optional): Unique identifier for the
+                element. (default: :obj:`None`)
+            embeddings (List[float], optional): A list of float
+                numbers representing the text embeddings.
+                (default: :obj:`None`)
             filename (Optional[str], optional): The name of the file the
-                element is associated with. Defaults to `None`.
+                element is associated with. (default: :obj:`None`)
             file_directory (Optional[str], optional): The directory path where
-                the file is located. Defaults to `None`.
+                the file is located. (default: :obj:`None`)
             last_modified (Optional[str], optional): The last modified date of
-                the file. Defaults to `None`.
-            filetype (Optional[str], optional): The type of the file. Defaults
-                to `None`.
-            parent_id (Optional[Union[str, uuid.UUID]], optional): The
-                identifier of the parent element. Defaults to `None`.
+                the file. (default: :obj:`None`)
+            filetype (Optional[str], optional): The type of the file.
+                (default: :obj:`None`)
+            parent_id (Optional[str], optional): The identifier of the parent
+                element. (default: :obj:`None`)
 
         Returns:
             Element: An instance of Text with the provided content and
@@ -83,7 +87,7 @@ class UnstructuredIO:
 
         return Text(
             text=text,
-            element_id=element_id or uuid.uuid4(),
+            element_id=element_id or str(uuid.uuid4()),
             metadata=metadata,
             embeddings=embeddings,
         )
@@ -92,7 +96,7 @@ class UnstructuredIO:
     def parse_file_or_url(
         input_path: str,
         **kwargs: Any,
-    ) -> Union[List[Element], None]:
+    ) -> Union[List["Element"], None]:
         r"""Loads a file or a URL and parses its contents into elements.
 
         Args:
@@ -108,7 +112,7 @@ class UnstructuredIO:
                 specified.
 
         Notes:
-            Available document types:
+            Supported file types:
                 "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
                 "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
 
@@ -118,25 +122,23 @@ class UnstructuredIO:
         import os
         from urllib.parse import urlparse
 
+        from unstructured.partition.auto import partition
+
         # Check if the input is a URL
         parsed_url = urlparse(input_path)
         is_url = all([parsed_url.scheme, parsed_url.netloc])
 
+        # Handling URL
         if is_url:
-            # Handling URL
-            from unstructured.partition.html import partition_html
-
             try:
-                elements = partition_html(url=input_path, **kwargs)
+                elements = partition(url=input_path, **kwargs)
                 return elements
             except Exception:
                 warnings.warn(f"Failed to parse the URL: {input_path}")
                 return None
 
+        # Handling file
         else:
-            # Handling file
-            from unstructured.partition.auto import partition
-
             # Check if the file exists
             if not os.path.exists(input_path):
                 raise FileNotFoundError(
@@ -152,6 +154,39 @@ class UnstructuredIO:
                 warnings.warn(f"Failed to partition the file: {input_path}")
                 return None
 
+    @staticmethod
+    def parse_bytes(
+        file: IO[bytes], **kwargs: Any
+    ) -> Union[List["Element"], None]:
+        r"""Parses a bytes stream and converts its contents into elements.
+
+        Args:
+            file (IO[bytes]): The file in bytes format to be parsed.
+            **kwargs: Extra kwargs passed to the partition function.
+
+        Returns:
+            Union[List[Element], None]: List of elements after parsing the file
+                if successful, otherwise `None`.
+
+        Notes:
+            Supported file types:
+                "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
+                "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
+
+        References:
+            https://docs.unstructured.io/open-source/core-functionality/partitioning
+        """
+
+        from unstructured.partition.auto import partition
+
+        try:
+            # Use partition to process the bytes stream
+            elements = partition(file=file, **kwargs)
+            return elements
+        except Exception as e:
+            warnings.warn(f"Failed to partition the file stream: {e}")
+            return None
+
     @staticmethod
     def clean_text_data(
         text: str,
@@ -162,7 +197,7 @@ class UnstructuredIO:
 
         This function applies multiple text cleaning utilities by calling the
         `unstructured` library's cleaning bricks for operations like
-        replacing unicode quotes, removing extra whitespace, dashes, non-ascii
+        replacing Unicode quotes, removing extra whitespace, dashes, non-ascii
         characters, and more.
 
         If no cleaning options are provided, a default set of cleaning
@@ -249,7 +284,8 @@ class UnstructuredIO:
                 )
             else:
                 raise ValueError(
-                    f"'{func_name}' is not a valid function in `unstructured`."
+                    f"'{func_name}' is not a valid function in "
+                    "`Unstructured IO`."
                 )
 
         return cleaned_text
@@ -406,8 +442,8 @@ class UnstructuredIO:
 
     @staticmethod
     def chunk_elements(
-        elements: List[Any], chunk_type: str, **kwargs
-    ) -> List[Element]:
+        elements: List["Element"], chunk_type: str, **kwargs
+    ) -> List["Element"]:
         r"""Chunks elements by titles.
 
         Args:

camel/messages/__init__.py

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

camel/messages/func_message.py

@@ -93,10 +93,10 @@ class FunctionCallingMessage(BaseMessage):
             OpenAIMessage: The converted :obj:`OpenAIMessage` object
                 with its role being "function".
         """
-        if (not self.func_name) or (not self.result):
+        if not self.func_name:
             raise ValueError(
                 "Invalid request for converting into function message"
-                " due to missing function name or results."
+                " due to missing function name."
             )
 
         result_content = {"result": {str(self.result)}}

camel/models/__init__.py

@@ -21,9 +21,8 @@ from .mistral_model import MistralModel
 from .model_factory import ModelFactory
 from .nemotron_model import NemotronModel
 from .ollama_model import OllamaModel
-from .open_source_model import OpenSourceModel
 from .openai_audio_models import OpenAIAudioModels
-from .openai_compatibility_model import OpenAICompatibilityModel
+from .openai_compatible_model import OpenAICompatibleModel
 from .openai_model import OpenAIModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
@@ -41,7 +40,6 @@ __all__ = [
     'GroqModel',
     'StubModel',
     'ZhipuAIModel',
-    'OpenSourceModel',
     'ModelFactory',
     'LiteLLMModel',
     'OpenAIAudioModels',
@@ -49,7 +47,7 @@ __all__ = [
     'OllamaModel',
     'VLLMModel',
     'GeminiModel',
-    'OpenAICompatibilityModel',
+    'OpenAICompatibleModel',
     'RekaModel',
     'SambaModel',
     'TogetherAIModel',

camel/models/anthropic_model.py

@@ -12,11 +12,9 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from anthropic import NOT_GIVEN, Anthropic
-
-from camel.configs import ANTHROPIC_API_PARAMS
+from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
 from camel.messages import OpenAIMessage
 from camel.models.base_model import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -24,40 +22,47 @@ from camel.utils import (
     AnthropicTokenCounter,
     BaseTokenCounter,
     api_keys_required,
+    dependencies_required,
 )
 
 
 class AnthropicModel(BaseModelBackend):
-    r"""Anthropic API in a unified BaseModelBackend interface."""
-
+    r"""Anthropic API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of CLAUDE_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into Anthropic.messages.create().  If
+            :obj:`None`, :obj:`AnthropicConfig().as_dict()` will be used.
+            (default::obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Anthropic service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Anthropic service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`AnthropicTokenCounter`
+            will be used. (default: :obj:`None`)
+    """
+
+    @dependencies_required('anthropic')
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for Anthropic backend.
+        from anthropic import Anthropic
 
-        Args:
-            model_type (ModelType): Model for which a backend is created,
-                one of CLAUDE_* series.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into Anthropic.messages.create().
-            api_key (Optional[str]): The API key for authenticating with the
-                Anthropic service. (default: :obj:`None`)
-            url (Optional[str]): The url to the Anthropic service. (default:
-                :obj:`None`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `AnthropicTokenCounter` will
-                be used.
-        """
+        if model_config_dict is None:
+            model_config_dict = AnthropicConfig().as_dict()
+        api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        self._url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
         self.client = Anthropic(api_key=self._api_key, base_url=self._url)
 
     def _convert_response_from_anthropic_to_openai(self, response):
@@ -89,7 +94,7 @@ class AnthropicModel(BaseModelBackend):
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = AnthropicTokenCounter(self.model_type)
+            self._token_counter = AnthropicTokenCounter()
         return self._token_counter
 
     def count_tokens_from_prompt(self, prompt: str) -> int:
@@ -117,13 +122,14 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
+        from anthropic import NOT_GIVEN
 
         if messages[0]["role"] == "system":
             sys_msg = str(messages.pop(0)["content"])
         else:
             sys_msg = NOT_GIVEN  # type: ignore[assignment]
         response = self.client.messages.create(
-            model=self.model_type.value,
+            model=self.model_type,
             system=sys_msg,
             messages=messages,  # type: ignore[arg-type]
             **self.model_config_dict,

camel/models/azure_openai_model.py

@@ -16,60 +16,65 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import AzureOpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS
+from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
 from camel.messages import OpenAIMessage
 from camel.models.base_model import BaseModelBackend
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_keys_required
 
 
 class AzureOpenAIModel(BaseModelBackend):
     r"""Azure OpenAI API in a unified BaseModelBackend interface.
-    Doc: https://learn.microsoft.com/en-us/azure/ai-services/openai/
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of GPT_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`ChatGPTConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the OpenAI service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the OpenAI service.
+            (default: :obj:`None`)
+        api_version (Optional[str], optional): The api version for the model.
+            (default: :obj:`None`)
+        azure_deployment_name (Optional[str], optional): The deployment name
+            you chose when you deployed an azure model. (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter`
+            will be used. (default: :obj:`None`)
+
+    References:
+        https://learn.microsoft.com/en-us/azure/ai-services/openai/
     """
 
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
         api_version: Optional[str] = None,
         azure_deployment_name: Optional[str] = None,
     ) -> None:
-        r"""Constructor for OpenAI backend.
+        if model_config_dict is None:
+            model_config_dict = ChatGPTConfig().as_dict()
+        api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
+        url = url or os.environ.get("AZURE_OPENAI_BASE_URL")
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
 
-        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().
-            api_key (Optional[str]): The API key for authenticating with the
-                OpenAI service. (default: :obj:`None`)
-            url (Optional[str]): The url to the OpenAI service. (default:
-                :obj:`None`)
-            api_version (Optional[str]): The api version for the model.
-            azure_deployment_name (Optional[str]): The deployment name you
-                chose when you deployed an azure model. (default: :obj:`None`)
-        """
-        super().__init__(model_type, model_config_dict, api_key, url)
-        self._url = url or os.environ.get("AZURE_OPENAI_ENDPOINT")
-        self._api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
         self.azure_deployment_name = azure_deployment_name or os.environ.get(
             "AZURE_DEPLOYMENT_NAME"
         )
-
-        if self._url is None:
-            raise ValueError(
-                "Must provide either the `url` argument "
-                "or `AZURE_OPENAI_ENDPOINT` environment variable."
-            )
-        if self._api_key is None:
-            raise ValueError(
-                "Must provide either the `api_key` argument "
-                "or `AZURE_OPENAI_API_KEY` environment variable."
-            )
         if self.api_version is None:
             raise ValueError(
                 "Must provide either the `api_version` argument "
@@ -80,7 +85,6 @@ class AzureOpenAIModel(BaseModelBackend):
                 "Must provide either the `azure_deployment_name` argument "
                 "or `AZURE_DEPLOYMENT_NAME` environment variable."
             )
-        self.model = str(self.azure_deployment_name)
 
         self._client = AzureOpenAI(
             azure_endpoint=str(self._url),
@@ -90,7 +94,6 @@ class AzureOpenAIModel(BaseModelBackend):
             timeout=60,
             max_retries=3,
         )
-        self._token_counter: Optional[BaseTokenCounter] = None
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -122,7 +125,7 @@ class AzureOpenAIModel(BaseModelBackend):
         """
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
             **self.model_config_dict,
         )
         return response

camel/models/base_model.py

@@ -17,41 +17,49 @@ from typing import Any, Dict, List, Optional, Union
 from openai import Stream
 
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+    UnifiedModelType,
+)
 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.
+    It may be OpenAI API, a local LLM, a stub for unit tests, etc.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A config
+            dictionary. (default: :obj:`{}`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the model service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token
+            counter to use for the model. If not provided,
+            :obj:`OpenAITokenCounter` will be used. (default: :obj:`None`)
     """
 
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> 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.
-            api_key (Optional[str]): The API key for authenticating with the
-                model service.
-            url (Optional[str]): The url to the model service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter` will
-                be used.
-        """
-        self.model_type = model_type
+        self.model_type: UnifiedModelType = UnifiedModelType(model_type)
+        if model_config_dict is None:
+            model_config_dict = {}
         self.model_config_dict = model_config_dict
         self._api_key = api_key
         self._url = url
-        self.check_model_config()
         self._token_counter = token_counter
+        self.check_model_config()
 
     @property
     @abstractmethod
@@ -110,6 +118,9 @@ class BaseModelBackend(ABC):
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
 
+        This method retrieves the maximum token limit either from the
+        `model_config_dict` or from the model's default token limit.
+
         Returns:
             int: The maximum token limit for the given model.
         """
@@ -120,8 +131,8 @@ class BaseModelBackend(ABC):
 
     @property
     def stream(self) -> bool:
-        r"""Returns whether the model is in stream mode,
-            which sends partial results each time.
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
 
         Returns:
             bool: Whether the model is in stream mode.

camel/models/gemini_model.py

@@ -11,9 +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 TYPE_CHECKING, Any, Dict, List, Optional
+import os
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from camel.configs import Gemini_API_PARAMS
+from camel.configs import Gemini_API_PARAMS, GeminiConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -26,6 +27,7 @@ from camel.utils import (
     BaseTokenCounter,
     GeminiTokenCounter,
     api_keys_required,
+    dependencies_required,
 )
 
 if TYPE_CHECKING:
@@ -33,43 +35,49 @@ if TYPE_CHECKING:
 
 
 class GeminiModel(BaseModelBackend):
-    r"""Gemini API in a unified BaseModelBackend interface."""
-
-    # NOTE: Currently "stream": True is not supported with Gemini due to the
-    # limitation of the current camel design.
-
+    r"""Gemini API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`genai.GenerativeModel.generate_content()
+            `. If:obj:`None`, :obj:`GeminiConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the gemini service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the gemini service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`GeminiTokenCounter` will
+            be used. (default: :obj:`None`)
+
+    Notes:
+        Currently :obj:`"stream": True` is not supported with Gemini due to the
+        limitation of the current camel design.
+    """
+
+    @dependencies_required('google')
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for Gemini backend.
-
-        Args:
-            model_type (ModelType): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into generate_content().
-            api_key (Optional[str]): The API key for authenticating with the
-                gemini service. (default: :obj:`None`)
-            url (Optional[str]): The url to the gemini service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `GeminiTokenCounter` will be
-                used.
-        """
-        import os
-
         import google.generativeai as genai
         from google.generativeai.types.generation_types import GenerationConfig
 
+        if model_config_dict is None:
+            model_config_dict = GeminiConfig().as_dict()
+
+        api_key = api_key or os.environ.get("GOOGLE_API_KEY")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._api_key = api_key or os.environ.get("GOOGLE_API_KEY")
         genai.configure(api_key=self._api_key)
-        self._client = genai.GenerativeModel(self.model_type.value)
+        self._client = genai.GenerativeModel(self.model_type)
 
         keys = list(self.model_config_dict.keys())
         generation_config_dict = {
@@ -143,8 +151,8 @@ class GeminiModel(BaseModelBackend):
         return self.model_config_dict.get('stream', False)
 
     def to_gemini_req(self, messages: List[OpenAIMessage]) -> 'ContentsType':
-        r"""Converts the request from the OpenAI API format to
-            the Gemini API request format.
+        r"""Converts the request from the OpenAI API format to the Gemini API
+        request format.
 
         Args:
             messages: The request object from the OpenAI API.
@@ -189,7 +197,7 @@ class GeminiModel(BaseModelBackend):
             id=f"chatcmpl-{uuid.uuid4().hex!s}",
             object="chat.completion",
             created=int(time.time()),
-            model=self.model_type.value,
+            model=self.model_type,
             choices=[],
         )
         for i, candidate in enumerate(response.candidates):