camel-ai 0.2.22__py3-none-any.whl → 0.2.23__py3-none-any.whl

camel/models/deepseek_model.py

@@ -13,13 +13,15 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from openai import OpenAI, Stream
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import DEEPSEEK_API_PARAMS, DeepSeekConfig
 from camel.logger import get_logger
 from camel.messages import OpenAIMessage
+from camel.models._utils import try_modify_message_with_format
 from camel.models.base_model import BaseModelBackend
 from camel.types import (
     ChatCompletion,
@@ -30,6 +32,16 @@ from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_keys_required
 
 logger = get_logger(__name__)
 
+REASONSER_UNSUPPORTED_PARAMS = [
+    "temperature",
+    "top_p",
+    "presence_penalty",
+    "frequency_penalty",
+    "logprobs",
+    "top_logprobs",
+    "tools",
+]
+
 
 class DeepSeekModel(BaseModelBackend):
     r"""DeepSeek API in a unified BaseModelBackend interface.
@@ -84,6 +96,13 @@ class DeepSeekModel(BaseModelBackend):
             base_url=self._url,
         )
 
+        self._async_client = AsyncOpenAI(
+            timeout=180,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -98,64 +117,51 @@ class DeepSeekModel(BaseModelBackend):
             )
         return self._token_counter
 
-    def run(
+    def _prepare_request(
         self,
         messages: List[OpenAIMessage],
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-        r"""Runs inference of DeepSeek chat completion.
-
-        Args:
-            messages (List[OpenAIMessage]): Message list with the chat history
-                in OpenAI API format.
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        request_config = self.model_config_dict.copy()
 
-        Returns:
-            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
-        """
-        # deepseek reasoner has limitations
-        # reference: https://api-docs.deepseek.com/guides/reasoning_model#api-parameters
         if self.model_type in [
             ModelType.DEEPSEEK_REASONER,
         ]:
             logger.warning(
-                "You are using a DeepSeek Reasoner model, "
+                "Warning: You are using an DeepSeek Reasoner model, "
                 "which has certain limitations, reference: "
-                "`https://api-docs.deepseek.com/guides/reasoning_model#api-parameters`"
+                "`https://api-docs.deepseek.com/guides/reasoning_model"
+                "#api-parameters`.",
             )
+            request_config = {
+                key: value
+                for key, value in request_config.items()
+                if key not in REASONSER_UNSUPPORTED_PARAMS
+            }
 
-            # Check and remove unsupported parameters and reset the fixed
-            # parameters
-            unsupported_keys = [
-                "temperature",
-                "top_p",
-                "presence_penalty",
-                "frequency_penalty",
-                "logprobs",
-                "top_logprobs",
-                "tools",
-            ]
-            for key in unsupported_keys:
-                if key in self.model_config_dict:
-                    del self.model_config_dict[key]
+        if tools:
+            for tool in tools:
+                function_dict = tool.get('function', {})
+                function_dict.pop("strict", None)
+            request_config["tools"] = tools
+        elif response_format:
+            try_modify_message_with_format(messages[-1], response_format)
+            request_config["response_format"] = {"type": "json_object"}
 
-        response = self._client.chat.completions.create(
-            messages=messages,
-            model=self.model_type,
-            **self.model_config_dict,
-        )
+        return request_config
 
-        # Handle reasoning content with <think> tags at the beginning
+    def _post_handle_response(
+        self, response: ChatCompletion
+    ) -> ChatCompletion:
+        r"""Handle reasoning content with <think> tags at the beginning."""
         if (
-            self.model_type
-            in [
-                ModelType.DEEPSEEK_REASONER,
-            ]
+            self.model_type in [ModelType.DEEPSEEK_REASONER]
             and os.environ.get("GET_REASONING_CONTENT", "false").lower()
             == "true"
         ):
-            reasoning_content = response.choices[0].message.reasoning_content
-            combined_content = (
+            reasoning_content = response.choices[0].message.reasoning_content  # type: ignore[attr-defined]
+            combined_content = (  # type: ignore[operator]
                 f"<think>\n{reasoning_content}\n</think>\n"
                 if reasoning_content
                 else ""
@@ -181,9 +187,65 @@ class DeepSeekModel(BaseModelBackend):
                 object="chat.completion",
                 usage=response.usage,
             )
-
         return response
 
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of DeepSeek 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.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+        return self._post_handle_response(response)
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of DeepSeek chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+        return self._post_handle_response(response)
+
     def check_model_config(self):
         r"""Check whether the model configuration contains any
         unexpected arguments to DeepSeek API.

camel/models/fish_audio_model.py

@@ -15,8 +15,10 @@
 import os
 from typing import Any, Optional
 
+from camel.models.base_audio_model import BaseAudioModel
 
-class FishAudioModel:
+
+class FishAudioModel(BaseAudioModel):
     r"""Provides access to FishAudio's Text-to-Speech (TTS) and Speech_to_Text
     (STT) models.
     """
@@ -37,6 +39,7 @@ class FishAudioModel:
         """
         from fish_audio_sdk import Session
 
+        super().__init__(api_key, url)
         self._api_key = api_key or os.environ.get("FISHAUDIO_API_KEY")
         self._url = url or os.environ.get(
             "FISHAUDIO_API_BASE_URL", "https://api.fish.audio"
@@ -46,7 +49,8 @@ class FishAudioModel:
     def text_to_speech(
         self,
         input: str,
-        storage_path: str,
+        *,
+        storage_path: Optional[str] = None,
         reference_id: Optional[str] = None,
         reference_audio: Optional[str] = None,
         reference_audio_text: Optional[str] = None,
@@ -55,9 +59,9 @@ class FishAudioModel:
         r"""Convert text to speech and save the output to a file.
 
         Args:
-            input_text (str): The text to convert to speech.
-            storage_path (str): The file path where the resulting speech will
-                be saved.
+            input (str): The text to convert to speech.
+            storage_path (Optional[str]): The file path where the resulting
+                speech will be saved. (default: :obj:`None`)
             reference_id (Optional[str]): An optional reference ID to
                 associate with the request. (default: :obj:`None`)
             reference_audio (Optional[str]): Path to an audio file for
@@ -68,12 +72,18 @@ class FishAudioModel:
 
         Raises:
             FileNotFoundError: If the reference audio file cannot be found.
+            ValueError: If storage_path is not provided or if reference_audio
+                is provided without reference_audio_text.
         """
         from fish_audio_sdk import ReferenceAudio, TTSRequest
 
-        directory = os.path.dirname(storage_path)
-        if directory and not os.path.exists(directory):
-            os.makedirs(directory)
+        if storage_path is None:
+            raise ValueError(
+                "storage_path must be provided for "
+                "FishAudioModel.text_to_speech"
+            )
+
+        self._ensure_directory_exists(storage_path)
 
         if not reference_audio:
             with open(f"{storage_path}", "wb") as f:

camel/models/gemini_model.py

@@ -12,9 +12,10 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from openai import OpenAI, Stream
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import Gemini_API_PARAMS, GeminiConfig
 from camel.messages import OpenAIMessage
@@ -81,37 +82,154 @@ class GeminiModel(BaseModelBackend):
             api_key=self._api_key,
             base_url=self._url,
         )
+        self._async_client = AsyncOpenAI(
+            timeout=180,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
 
-    def run(
+    def _process_messages(self, messages) -> List[OpenAIMessage]:
+        r"""Process the messages for Gemini API to ensure no empty content,
+        which is not accepted by Gemini.
+        """
+        processed_messages = []
+        for msg in messages:
+            msg_copy = msg.copy()
+            if 'content' in msg_copy and msg_copy['content'] == '':
+                msg_copy['content'] = 'null'
+            processed_messages.append(msg_copy)
+        return processed_messages
+
+    def _run(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
         r"""Runs inference of Gemini chat completion.
 
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Process messages to ensure no empty content, it's not accepeted by
-        # Gemini
-        processed_messages = []
-        for msg in messages:
-            msg_copy = msg.copy()
-            if 'content' in msg_copy and msg_copy['content'] == '':
-                msg_copy['content'] = 'null'
-            processed_messages.append(msg_copy)
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        messages = self._process_messages(messages)
+        if response_format:
+            return self._request_parse(messages, response_format)
+        else:
+            return self._request_chat_completion(messages, tools)
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion in async mode.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        messages = self._process_messages(messages)
+        if response_format:
+            return await self._arequest_parse(messages, response_format)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            for tool in tools:
+                function_dict = tool.get('function', {})
+                function_dict.pop("strict", None)
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            for tool in tools:
+                function_dict = tool.get('function', {})
+                function_dict.pop("strict", None)
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
 
-        response = self._client.chat.completions.create(
-            messages=processed_messages,
+        return await self._async_client.beta.chat.completions.parse(
+            messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
     @property
     def token_counter(self) -> BaseTokenCounter:

camel/models/groq_model.py

@@ -12,13 +12,15 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from openai import OpenAI, Stream
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import GROQ_API_PARAMS, GroqConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
+from camel.models._utils import try_modify_message_with_format
 from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
@@ -51,11 +53,7 @@ class GroqModel(BaseModelBackend):
             (default: :obj:`None`)
     """
 
-    @api_keys_required(
-        [
-            ("api_key", "GROQ_API_KEY"),
-        ]
-    )
+    @api_keys_required([("api_key", "GROQ_API_KEY")])
     def __init__(
         self,
         model_type: Union[ModelType, str],
@@ -79,6 +77,12 @@ class GroqModel(BaseModelBackend):
             api_key=self._api_key,
             base_url=self._url,
         )
+        self._async_client = AsyncOpenAI(
+            timeout=180,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -92,25 +96,83 @@ class GroqModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
-    def run(
+    def _prepare_request(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        request_config = self.model_config_dict.copy()
+        if tools:
+            request_config["tools"] = tools
+        elif response_format:
+            try_modify_message_with_format(messages[-1], response_format)
+            request_config["response_format"] = {"type": "json_object"}
+
+        return request_config
+
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-        r"""Runs inference of OpenAI chat completion.
+        r"""Runs inference of Groq chat completion.
 
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
         response = self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
+        )
+
+        return response
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of Groq chat completion asynchronously.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
         )
 
         return response

camel/models/internlm_model.py

@@ -13,9 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from openai import OpenAI, Stream
+from openai import AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import INTERNLM_API_PARAMS, InternLMConfig
 from camel.messages import OpenAIMessage
@@ -82,9 +83,11 @@ class InternLMModel(BaseModelBackend):
             base_url=self._url,
         )
 
-    def run(
+    def _run(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
         r"""Runs inference of InternLM chat completion.
 
@@ -104,6 +107,14 @@ class InternLMModel(BaseModelBackend):
         )
         return response
 
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        raise NotImplementedError("InternLM does not support async inference.")
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.

camel/models/litellm_model.py

@@ -11,7 +11,9 @@
 # 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 Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 from camel.configs import LITELLM_API_PARAMS, LiteLLMConfig
 from camel.messages import OpenAIMessage
@@ -106,9 +108,14 @@ class LiteLLMModel(BaseModelBackend):
             self._token_counter = LiteLLMTokenCounter(self.model_type)
         return self._token_counter
 
-    def run(
+    async def _arun(self) -> None:  # type: ignore[override]
+        raise NotImplementedError
+
+    def _run(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> ChatCompletion:
         r"""Runs inference of LiteLLM chat completion.