camel-ai 0.1.5.5__py3-none-any.whl → 0.1.5.9__py3-none-any.whl

camel/types/enums.py

@@ -29,11 +29,22 @@ class ModelType(Enum):
     GPT_4_32K = "gpt-4-32k"
     GPT_4_TURBO = "gpt-4-turbo"
     GPT_4O = "gpt-4o"
+    GPT_4O_MINI = "gpt-4o-mini"
+
     GLM_4 = "glm-4"
     GLM_4_OPEN_SOURCE = "glm-4-open-source"
     GLM_4V = 'glm-4v'
     GLM_3_TURBO = "glm-3-turbo"
 
+    GROQ_LLAMA_3_1_8B = "llama-3.1-8b-instant"
+    GROQ_LLAMA_3_1_70B = "llama-3.1-70b-versatile"
+    GROQ_LLAMA_3_1_405B = "llama-3.1-405b-reasoning"
+    GROQ_LLAMA_3_8B = "llama3-8b-8192"
+    GROQ_LLAMA_3_70B = "llama3-70b-8192"
+    GROQ_MIXTRAL_8_7B = "mixtral-8x7b-32768"
+    GROQ_GEMMA_7B_IT = "gemma-7b-it"
+    GROQ_GEMMA_2_9B_IT = "gemma2-9b-it"
+
     STUB = "stub"
 
     LLAMA_2 = "llama-2"
@@ -44,7 +55,7 @@ class ModelType(Enum):
     QWEN_2 = "qwen-2"
 
     # Legacy anthropic models
-    # NOTE: anthropic lagecy models only Claude 2.1 has system prompt support
+    # NOTE: anthropic legacy models only Claude 2.1 has system prompt support
     CLAUDE_2_1 = "claude-2.1"
     CLAUDE_2_0 = "claude-2.0"
     CLAUDE_INSTANT_1_2 = "claude-instant-1.2"
@@ -58,6 +69,19 @@ class ModelType(Enum):
     # Nvidia models
     NEMOTRON_4_REWARD = "nvidia/nemotron-4-340b-reward"
 
+    # Gemini models
+    GEMINI_1_5_FLASH = "gemini-1.5-flash"
+    GEMINI_1_5_PRO = "gemini-1.5-pro"
+
+    # Mistral AI Model
+    MISTRAL_LARGE = "mistral-large-latest"
+    MISTRAL_NEMO = "open-mistral-nemo"
+    MISTRAL_CODESTRAL = "codestral-latest"
+    MISTRAL_7B = "open-mistral-7b"
+    MISTRAL_MIXTRAL_8x7B = "open-mixtral-8x7b"
+    MISTRAL_MIXTRAL_8x22B = "open-mixtral-8x22b"
+    MISTRAL_CODESTRAL_MAMBA = "open-codestral-mamba"
+
     @property
     def value_for_tiktoken(self) -> str:
         return (
@@ -69,6 +93,20 @@ class ModelType(Enum):
     @property
     def is_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model."""
+        return self in {
+            ModelType.GPT_3_5_TURBO,
+            ModelType.GPT_4,
+            ModelType.GPT_4_32K,
+            ModelType.GPT_4_TURBO,
+            ModelType.GPT_4O,
+            ModelType.GPT_4O_MINI,
+        }
+
+    @property
+    def is_azure_openai(self) -> bool:
+        r"""Returns whether this type of models is an OpenAI-released model
+        from Azure.
+        """
         return self in {
             ModelType.GPT_3_5_TURBO,
             ModelType.GPT_4,
@@ -115,6 +153,33 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_5_SONNET,
         }
 
+    @property
+    def is_groq(self) -> bool:
+        r"""Returns whether this type of models is served by Groq."""
+        return self in {
+            ModelType.GROQ_LLAMA_3_1_8B,
+            ModelType.GROQ_LLAMA_3_1_70B,
+            ModelType.GROQ_LLAMA_3_1_405B,
+            ModelType.GROQ_LLAMA_3_8B,
+            ModelType.GROQ_LLAMA_3_70B,
+            ModelType.GROQ_MIXTRAL_8_7B,
+            ModelType.GROQ_GEMMA_7B_IT,
+            ModelType.GROQ_GEMMA_2_9B_IT,
+        }
+
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether this type of models is served by Mistral."""
+        return self in {
+            ModelType.MISTRAL_LARGE,
+            ModelType.MISTRAL_NEMO,
+            ModelType.MISTRAL_CODESTRAL,
+            ModelType.MISTRAL_7B,
+            ModelType.MISTRAL_MIXTRAL_8x7B,
+            ModelType.MISTRAL_MIXTRAL_8x22B,
+            ModelType.MISTRAL_CODESTRAL_MAMBA,
+        }
+
     @property
     def is_nvidia(self) -> bool:
         r"""Returns whether this type of models is Nvidia-released model.
@@ -126,45 +191,70 @@ class ModelType(Enum):
             ModelType.NEMOTRON_4_REWARD,
         }
 
+    @property
+    def is_gemini(self) -> bool:
+        return self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}
+
     @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.
         """
-        if self is ModelType.GPT_3_5_TURBO:
-            return 16385
-        elif self is ModelType.GPT_4:
-            return 8192
-        elif self is ModelType.GPT_4_32K:
-            return 32768
-        elif self is ModelType.GPT_4_TURBO:
-            return 128000
-        elif self is ModelType.GPT_4O:
-            return 128000
-        elif self == ModelType.GLM_4_OPEN_SOURCE:
-            return 8192
-        elif self == ModelType.GLM_3_TURBO:
-            return 8192
-        elif self == ModelType.GLM_4V:
+        if self is ModelType.GLM_4V:
             return 1024
-        elif self is ModelType.STUB:
-            return 4096
-        elif self is ModelType.LLAMA_2:
-            return 4096
-        elif self is ModelType.LLAMA_3:
-            return 8192
-        elif self is ModelType.QWEN_2:
-            return 128000
-        elif self is ModelType.GLM_4:
-            return 8192
         elif self is ModelType.VICUNA:
             # reference: https://lmsys.org/blog/2023-03-30-vicuna/
             return 2048
+        elif self in {
+            ModelType.GPT_3_5_TURBO,
+            ModelType.LLAMA_2,
+            ModelType.NEMOTRON_4_REWARD,
+            ModelType.STUB,
+        }:
+            return 4_096
+        elif self in {
+            ModelType.GPT_4,
+            ModelType.GROQ_LLAMA_3_8B,
+            ModelType.GROQ_LLAMA_3_70B,
+            ModelType.GROQ_GEMMA_7B_IT,
+            ModelType.GROQ_GEMMA_2_9B_IT,
+            ModelType.LLAMA_3,
+            ModelType.GLM_3_TURBO,
+            ModelType.GLM_4,
+            ModelType.GLM_4_OPEN_SOURCE,
+        }:
+            return 8_192
         elif self is ModelType.VICUNA_16K:
-            return 16384
+            return 16_384
+        elif self in {
+            ModelType.GPT_4_32K,
+            ModelType.MISTRAL_CODESTRAL,
+            ModelType.MISTRAL_7B,
+            ModelType.MISTRAL_MIXTRAL_8x7B,
+            ModelType.GROQ_MIXTRAL_8_7B,
+        }:
+            return 32_768
+        elif self in {ModelType.MISTRAL_MIXTRAL_8x22B}:
+            return 64_000
         elif self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
             return 100_000
+        elif self in {
+            ModelType.GPT_4O,
+            ModelType.GPT_4O_MINI,
+            ModelType.GPT_4_TURBO,
+            ModelType.MISTRAL_LARGE,
+            ModelType.MISTRAL_NEMO,
+            ModelType.QWEN_2,
+        }:
+            return 128_000
+        elif self in {
+            ModelType.GROQ_LLAMA_3_1_8B,
+            ModelType.GROQ_LLAMA_3_1_70B,
+            ModelType.GROQ_LLAMA_3_1_405B,
+        }:
+            return 131_072
         elif self in {
             ModelType.CLAUDE_2_1,
             ModelType.CLAUDE_3_OPUS,
@@ -173,8 +263,12 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_5_SONNET,
         }:
             return 200_000
-        elif self is ModelType.NEMOTRON_4_REWARD:
-            return 4096
+        elif self in {
+            ModelType.MISTRAL_CODESTRAL_MAMBA,
+        }:
+            return 256_000
+        elif self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}:
+            return 1_048_576
         else:
             raise ValueError("Unknown model type")
 
@@ -183,8 +277,9 @@ class ModelType(Enum):
 
         Args:
             model_name (str): The name of the model, e.g. "vicuna-7b-v1.5".
+
         Returns:
-            bool: Whether the model type mathches the model name.
+            bool: Whether the model type matches the model name.
         """
         if self is ModelType.VICUNA:
             pattern = r'^vicuna-\d+b-v\d+\.\d+$'
@@ -220,6 +315,8 @@ class EmbeddingModelType(Enum):
     TEXT_EMBEDDING_3_SMALL = "text-embedding-3-small"
     TEXT_EMBEDDING_3_LARGE = "text-embedding-3-large"
 
+    MISTRAL_EMBED = "mistral-embed"
+
     @property
     def is_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model."""
@@ -229,6 +326,15 @@ class EmbeddingModelType(Enum):
             EmbeddingModelType.TEXT_EMBEDDING_3_LARGE,
         }
 
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether this type of models is an Mistral-released
+        model.
+        """
+        return self in {
+            EmbeddingModelType.MISTRAL_EMBED,
+        }
+
     @property
     def output_dim(self) -> int:
         if self is EmbeddingModelType.TEXT_EMBEDDING_ADA_2:
@@ -237,6 +343,8 @@ class EmbeddingModelType(Enum):
             return 1536
         elif self is EmbeddingModelType.TEXT_EMBEDDING_3_LARGE:
             return 3072
+        elif self is EmbeddingModelType.MISTRAL_EMBED:
+            return 1024
         else:
             raise ValueError(f"Unknown model type {self}.")
 
@@ -273,6 +381,7 @@ class OpenAIBackendRole(Enum):
     SYSTEM = "system"
     USER = "user"
     FUNCTION = "function"
+    TOOL = "tool"
 
 
 class TerminationMode(Enum):
@@ -326,11 +435,15 @@ class ModelPlatformType(Enum):
     OPENAI = "openai"
     AZURE = "azure"
     ANTHROPIC = "anthropic"
+    GROQ = "groq"
     OPENSOURCE = "opensource"
     OLLAMA = "ollama"
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
     DEFAULT = "default"
+    GEMINI = "gemini"
+    VLLM = "vllm"
+    MISTRAL = "mistral"
 
     @property
     def is_openai(self) -> bool:
@@ -347,11 +460,21 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is anthropic."""
         return self is ModelPlatformType.ANTHROPIC
 
+    @property
+    def is_groq(self) -> bool:
+        r"""Returns whether this platform is groq."""
+        return self is ModelPlatformType.GROQ
+
     @property
     def is_ollama(self) -> bool:
         r"""Returns whether this platform is ollama."""
         return self is ModelPlatformType.OLLAMA
 
+    @property
+    def is_vllm(self) -> bool:
+        r"""Returns whether this platform is vllm."""
+        return self is ModelPlatformType.VLLM
+
     @property
     def is_litellm(self) -> bool:
         r"""Returns whether this platform is litellm."""
@@ -362,11 +485,21 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is zhipu."""
         return self is ModelPlatformType.ZHIPU
 
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether this platform is mistral."""
+        return self is ModelPlatformType.MISTRAL
+
     @property
     def is_open_source(self) -> bool:
         r"""Returns whether this platform is opensource."""
         return self is ModelPlatformType.OPENSOURCE
 
+    @property
+    def is_gemini(self) -> bool:
+        r"""Returns whether this platform is Gemini."""
+        return self is ModelPlatformType.GEMINI
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

camel/utils/__init__.py

@@ -32,7 +32,9 @@ from .constants import Constants
 from .token_counting import (
     AnthropicTokenCounter,
     BaseTokenCounter,
+    GeminiTokenCounter,
     LiteLLMTokenCounter,
+    MistralTokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
     get_model_encoding,
@@ -60,4 +62,6 @@ __all__ = [
     'dependencies_required',
     'api_keys_required',
     'is_docker_running',
+    'GeminiTokenCounter',
+    'MistralTokenCounter',
 ]

camel/utils/async_func.py

@@ -14,7 +14,7 @@
 import asyncio
 from copy import deepcopy
 
-from camel.functions.openai_function import OpenAIFunction
+from camel.toolkits import OpenAIFunction
 
 
 def sync_funcs_to_async(funcs: list[OpenAIFunction]) -> list[OpenAIFunction]:

camel/utils/token_counting.py

@@ -26,6 +26,8 @@ from PIL import Image
 from camel.types import ModelType, OpenAIImageType, OpenAIVisionDetailType
 
 if TYPE_CHECKING:
+    from mistral_common.protocol.instruct.request import ChatCompletionRequest
+
     from camel.messages import OpenAIMessage
 
 LOW_DETAIL_TOKENS = 85
@@ -37,7 +39,7 @@ EXTRA_TOKENS = 85
 
 
 def messages_to_prompt(messages: List[OpenAIMessage], model: ModelType) -> str:
-    r"""Parse the message list into a single prompt following model-specifc
+    r"""Parse the message list into a single prompt following model-specific
     formats.
 
     Args:
@@ -51,7 +53,12 @@ def messages_to_prompt(messages: List[OpenAIMessage], model: ModelType) -> str:
     system_message = messages[0]["content"]
 
     ret: str
-    if model == ModelType.LLAMA_2 or model == ModelType.LLAMA_3:
+    if model in [
+        ModelType.LLAMA_2,
+        ModelType.LLAMA_3,
+        ModelType.GROQ_LLAMA_3_8B,
+        ModelType.GROQ_LLAMA_3_70B,
+    ]:
         # reference: https://github.com/facebookresearch/llama/blob/cfc3fc8c1968d390eb830e65c63865e980873a06/llama/generation.py#L212
         seps = [" ", " </s><s>"]
         role_map = {"user": "[INST]", "assistant": "[/INST]"}
@@ -74,7 +81,7 @@ def messages_to_prompt(messages: List[OpenAIMessage], model: ModelType) -> str:
             else:
                 ret += role
         return ret
-    elif model == ModelType.VICUNA or model == ModelType.VICUNA_16K:
+    elif model in [ModelType.VICUNA, ModelType.VICUNA_16K]:
         seps = [" ", "</s>"]
         role_map = {"user": "USER", "assistant": "ASSISTANT"}
 
@@ -132,6 +139,40 @@ def messages_to_prompt(messages: List[OpenAIMessage], model: ModelType) -> str:
             else:
                 ret += '<|im_start|>' + role + '\n'
         return ret
+    elif model == ModelType.GROQ_MIXTRAL_8_7B:
+        # Mistral/Mixtral format
+        system_prompt = f"<s>[INST] {system_message} [/INST]\n"
+        ret = system_prompt
+
+        for msg in messages[1:]:
+            if msg["role"] == "user":
+                ret += f"[INST] {msg['content']} [/INST]\n"
+            elif msg["role"] == "assistant":
+                ret += f"{msg['content']}</s>\n"
+
+            if not isinstance(msg['content'], str):
+                raise ValueError(
+                    "Currently multimodal context is not "
+                    "supported by the token counter."
+                )
+
+        return ret.strip()
+    elif model in [ModelType.GROQ_GEMMA_7B_IT, ModelType.GROQ_GEMMA_2_9B_IT]:
+        # Gemma format
+        ret = f"<bos>{system_message}\n"
+        for msg in messages:
+            if msg["role"] == "user":
+                ret += f"Human: {msg['content']}\n"
+            elif msg["role"] == "assistant":
+                ret += f"Assistant: {msg['content']}\n"
+
+            if not isinstance(msg['content'], str):
+                raise ValueError(
+                    "Currently multimodal context is not supported by the token counter."
+                )
+
+        ret += "<eos>"
+        return ret
     else:
         raise ValueError(f"Invalid model type: {model}")
 
@@ -232,6 +273,7 @@ class OpenAITokenCounter(BaseTokenCounter):
             model (ModelType): Model type for which tokens will be counted.
         """
         self.model: str = model.value_for_tiktoken
+        self.model_type = model
 
         self.tokens_per_message: int
         self.tokens_per_name: int
@@ -300,7 +342,7 @@ class OpenAITokenCounter(BaseTokenCounter):
                                 base64.b64decode(encoded_image)
                             )
                             image = Image.open(image_bytes)
-                            num_tokens += count_tokens_from_image(
+                            num_tokens += self._count_tokens_from_image(
                                 image, OpenAIVisionDetailType(detail)
                             )
                 if key == "name":
@@ -310,6 +352,45 @@ class OpenAITokenCounter(BaseTokenCounter):
         num_tokens += 3
         return num_tokens
 
+    def _count_tokens_from_image(
+        self, image: Image.Image, detail: OpenAIVisionDetailType
+    ) -> int:
+        r"""Count image tokens for OpenAI vision model. An :obj:`"auto"`
+        resolution model will be treated as :obj:`"high"`. All images with
+        :obj:`"low"` detail cost 85 tokens each. Images with :obj:`"high"` detail
+        are first scaled to fit within a 2048 x 2048 square, maintaining their
+        aspect ratio. Then, they are scaled such that the shortest side of the
+        image is 768px long. Finally, we count how many 512px squares the image
+        consists of. Each of those squares costs 170 tokens. Another 85 tokens are
+        always added to the final total. For more details please refer to `OpenAI
+        vision docs <https://platform.openai.com/docs/guides/vision>`_
+
+        Args:
+            image (PIL.Image.Image): Image to count number of tokens.
+            detail (OpenAIVisionDetailType): Image detail type to count
+                number of tokens.
+
+        Returns:
+            int: Number of tokens for the image given a detail type.
+        """
+        if detail == OpenAIVisionDetailType.LOW:
+            return LOW_DETAIL_TOKENS
+
+        width, height = image.size
+        if width > FIT_SQUARE_PIXELS or height > FIT_SQUARE_PIXELS:
+            scaling_factor = max(width, height) / FIT_SQUARE_PIXELS
+            width = int(width / scaling_factor)
+            height = int(height / scaling_factor)
+
+        scaling_factor = min(width, height) / SHORTEST_SIDE_PIXELS
+        scaled_width = int(width / scaling_factor)
+        scaled_height = int(height / scaling_factor)
+
+        h = ceil(scaled_height / SQUARE_PIXELS)
+        w = ceil(scaled_width / SQUARE_PIXELS)
+        total = EXTRA_TOKENS + SQUARE_TOKENS * h * w
+        return total
+
 
 class AnthropicTokenCounter(BaseTokenCounter):
     def __init__(self, model_type: ModelType):
@@ -342,6 +423,40 @@ class AnthropicTokenCounter(BaseTokenCounter):
         return num_tokens
 
 
+class GeminiTokenCounter(BaseTokenCounter):
+    def __init__(self, model_type: ModelType):
+        r"""Constructor for the token counter for Gemini models."""
+        import google.generativeai as genai
+
+        self.model_type = model_type
+        self._client = genai.GenerativeModel(self.model_type.value)
+
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Count number of tokens in the provided message list using
+        loaded tokenizer specific for this type of model.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            int: Number of tokens in the messages.
+        """
+        converted_messages = []
+        for message in messages:
+            role = message.get('role')
+            if role == 'assistant':
+                role_to_gemini = 'model'
+            else:
+                role_to_gemini = 'user'
+            converted_message = {
+                "role": role_to_gemini,
+                "parts": message.get("content"),
+            }
+            converted_messages.append(converted_message)
+        return self._client.count_tokens(converted_messages).total_tokens
+
+
 class LiteLLMTokenCounter:
     def __init__(self, model_type: str):
         r"""Constructor for the token counter for LiteLLM models.
@@ -394,41 +509,68 @@ class LiteLLMTokenCounter:
         return self.completion_cost(completion_response=response)
 
 
-def count_tokens_from_image(
-    image: Image.Image, detail: OpenAIVisionDetailType
-) -> int:
-    r"""Count image tokens for OpenAI vision model. An :obj:`"auto"`
-    resolution model will be treated as :obj:`"high"`. All images with
-    :obj:`"low"` detail cost 85 tokens each. Images with :obj:`"high"` detail
-    are first scaled to fit within a 2048 x 2048 square, maintaining their
-    aspect ratio. Then, they are scaled such that the shortest side of the
-    image is 768px long. Finally, we count how many 512px squares the image
-    consists of. Each of those squares costs 170 tokens. Another 85 tokens are
-    always added to the final total. For more details please refer to `OpenAI
-    vision docs <https://platform.openai.com/docs/guides/vision>`_
+class MistralTokenCounter(BaseTokenCounter):
+    def __init__(self, model_type: ModelType):
+        r"""Constructor for the token counter for Mistral models.
 
-    Args:
-        image (PIL.Image.Image): Image to count number of tokens.
-        detail (OpenAIVisionDetailType): Image detail type to count
-            number of tokens.
+        Args:
+            model_type (ModelType): Model type for which tokens will be
+                counted.
+        """
+        from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
 
-    Returns:
-        int: Number of tokens for the image given a detail type.
-    """
-    if detail == OpenAIVisionDetailType.LOW:
-        return LOW_DETAIL_TOKENS
-
-    width, height = image.size
-    if width > FIT_SQUARE_PIXELS or height > FIT_SQUARE_PIXELS:
-        scaling_factor = max(width, height) / FIT_SQUARE_PIXELS
-        width = int(width / scaling_factor)
-        height = int(height / scaling_factor)
-
-    scaling_factor = min(width, height) / SHORTEST_SIDE_PIXELS
-    scaled_width = int(width / scaling_factor)
-    scaled_height = int(height / scaling_factor)
-
-    h = ceil(scaled_height / SQUARE_PIXELS)
-    w = ceil(scaled_width / SQUARE_PIXELS)
-    total = EXTRA_TOKENS + SQUARE_TOKENS * h * w
-    return total
+        self.model_type = model_type
+
+        # Determine the model type and set the tokenizer accordingly
+        model_name = (
+            "codestral-22b"
+            if self.model_type
+            in {ModelType.MISTRAL_CODESTRAL, ModelType.MISTRAL_CODESTRAL_MAMBA}
+            else self.model_type.value
+        )
+
+        self.tokenizer = MistralTokenizer.from_model(model_name)
+
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Count number of tokens in the provided message list using
+        loaded tokenizer specific for this type of model.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            int: Total number of tokens in the messages.
+        """
+        total_tokens = 0
+        for msg in messages:
+            tokens = self.tokenizer.encode_chat_completion(
+                self._convert_response_from_openai_to_mistral(msg)
+            ).tokens
+            total_tokens += len(tokens)
+        return total_tokens
+
+    def _convert_response_from_openai_to_mistral(
+        self, openai_msg: OpenAIMessage
+    ) -> ChatCompletionRequest:
+        r"""Convert an OpenAI message to a Mistral ChatCompletionRequest.
+
+        Args:
+            openai_msg (OpenAIMessage): An individual message with OpenAI
+                format.
+
+        Returns:
+            ChatCompletionRequest: The converted message in Mistral's request
+                format.
+        """
+
+        from mistral_common.protocol.instruct.request import (
+            ChatCompletionRequest,
+        )
+
+        mistral_request = ChatCompletionRequest(  # type: ignore[type-var]
+            model=self.model_type.value,
+            messages=[openai_msg],
+        )
+
+        return mistral_request