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

camel/models/mistral_model.py

@@ -12,7 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from mistralai.models import (
@@ -20,10 +22,13 @@ if TYPE_CHECKING:
         Messages,
     )
 
+from openai import AsyncStream
+
 from camel.configs import MISTRAL_API_PARAMS, MistralConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
-from camel.types import ChatCompletion, ModelType
+from camel.models._utils import try_modify_message_with_format
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -212,25 +217,42 @@ class MistralModel(BaseModelBackend):
             )
         return self._token_counter
 
-    def run(
+    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("Mistral does not support async inference.")
+
+    def _run(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> ChatCompletion:
         r"""Runs inference of Mistral 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 for this query.
+            tools (Optional[List[Dict[str, Any]]]): The tools to use for this
+                query.
 
         Returns:
-            ChatCompletion.
+            ChatCompletion: The response from the model.
         """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
         mistral_messages = self._to_mistral_chatmessage(messages)
 
         response = self._client.chat.complete(
             messages=mistral_messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
         )
 
         openai_response = self._to_openai_response(response)  # type: ignore[arg-type]
@@ -251,6 +273,21 @@ class MistralModel(BaseModelBackend):
 
         return openai_response
 
+    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 check_model_config(self):
         r"""Check whether the model configuration contains any
         unexpected arguments to Mistral API.

camel/models/model_manager.py

@@ -20,10 +20,13 @@ from typing import (
     Callable,
     Dict,
     List,
+    Optional,
+    Type,
     Union,
 )
 
-from openai import Stream
+from openai import AsyncStream, Stream
+from pydantic import BaseModel
 
 from camel.messages import OpenAIMessage
 from camel.models.base_model import BaseModelBackend
@@ -114,6 +117,15 @@ class ModelManager:
         """
         return self.models.index(self.current_model)
 
+    @property
+    def num_models(self) -> int:
+        r"""Return the number of models in the manager.
+
+        Returns:
+            int: The number of models available in the model manager.
+        """
+        return len(self.models)
+
     @property
     def token_limit(self):
         r"""Returns the maximum token limit for current model.
@@ -178,7 +190,10 @@ class ModelManager:
         return choice(self.models)
 
     def run(
-        self, messages: List[OpenAIMessage]
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
         r"""Process a list of messages by selecting a model based on
             the scheduling strategy.
@@ -198,7 +213,46 @@ class ModelManager:
 
         # Pass all messages to the selected model and get the response
         try:
-            response = self.current_model.run(messages)
+            response = self.current_model.run(messages, response_format, tools)
+        except Exception as exc:
+            logger.error(f"Error processing with model: {self.current_model}")
+            if self.scheduling_strategy == self.always_first:
+                self.scheduling_strategy = self.round_robin
+                logger.warning(
+                    "The scheduling strategy has been changed to 'round_robin'"
+                )
+                # Skip already used one
+                self.current_model = self.scheduling_strategy()
+            raise exc
+        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"""Process a list of messages by selecting a model based on
+            the scheduling strategy.
+            Sends the entire list of messages to the selected model,
+            and returns a single response.
+
+        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.
+        """
+        self.current_model = self.scheduling_strategy()
+
+        # Pass all messages to the selected model and get the response
+        try:
+            response = await self.current_model.arun(
+                messages, response_format, tools
+            )
         except Exception as exc:
             logger.error(f"Error processing with model: {self.current_model}")
             if self.scheduling_strategy == self.always_first:

camel/models/moonshot_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 AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import MOONSHOT_API_PARAMS, MoonshotConfig
 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,
@@ -78,9 +80,24 @@ class MoonshotModel(BaseModelBackend):
             base_url=self._url,
         )
 
-    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)
+        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 Moonshot chat completion.
 
@@ -93,13 +110,25 @@ class MoonshotModel(BaseModelBackend):
                 `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]]:
+        raise NotImplementedError("Moonshot does not support async inference.")
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.

camel/models/nemotron_model.py

@@ -12,9 +12,10 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from openai import OpenAI
+from openai import AsyncOpenAI, OpenAI
+from pydantic import BaseModel
 
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
@@ -62,10 +63,38 @@ class NemotronModel(BaseModelBackend):
             base_url=self._url,
             api_key=self._api_key,
         )
+        self._async_client = AsyncOpenAI(
+            timeout=180,
+            max_retries=3,
+            base_url=self._url,
+            api_key=self._api_key,
+        )
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        r"""Runs inference of OpenAI chat completion asynchronously.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list.
+
+        Returns:
+            ChatCompletion.
+        """
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+        )
+        return response
 
-    def run(
+    def _run(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> ChatCompletion:
         r"""Runs inference of OpenAI chat completion.
 

camel/models/nvidia_model.py

@@ -13,13 +13,14 @@
 # ========= 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 openai.types.chat import (
     ChatCompletion,
     ChatCompletionChunk,
 )
+from pydantic import BaseModel
 
 from camel.configs import NVIDIA_API_PARAMS, NvidiaConfig
 from camel.messages import OpenAIMessage
@@ -76,10 +77,49 @@ class NvidiaModel(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,
+        )
+
+    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 NVIDIA 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.
+        """
+
+        # Remove tool-related parameters if no tools are specified
+        config = dict(self.model_config_dict)
+        if not config.get("tools"):  # None or empty list
+            config.pop("tools", None)
+            config.pop("tool_choice", None)
+
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **config,
+        )
+        return response
 
-    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 NVIDIA chat completion.
 

camel/models/ollama_model.py

@@ -13,13 +13,15 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
 import subprocess
-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 OLLAMA_API_PARAMS, OllamaConfig
 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,
@@ -75,6 +77,12 @@ class OllamaModel(BaseModelBackend):
             api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,
         )
+        self._async_client = AsyncOpenAI(
+            timeout=180,
+            max_retries=3,
+            api_key="Set-but-ignored",  # required but ignored
+            base_url=self._url,
+        )
 
     def _start_server(self) -> None:
         r"""Starts the Ollama server in a subprocess."""
@@ -119,40 +127,154 @@ class OllamaModel(BaseModelBackend):
                     "input into Ollama model backend."
                 )
 
-    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 OpenAI chat completion.
+        r"""Runs inference of Ollama 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.
         """
-        if self.model_config_dict.get("response_format"):
-            # stream is not supported in beta.chat.completions.parse
-            if "stream" in self.model_config_dict:
-                del self.model_config_dict["stream"]
-
-            response = self._client.beta.chat.completions.parse(
-                messages=messages,
-                model=self.model_type,
-                **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        # For Ollama, the tool calling will be broken with response_format
+        if response_format and not tools:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(
+                messages, response_format, 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 Ollama 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
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(
+                messages, response_format, tools
             )
 
-            return self._to_chat_completion(response)
+    def _prepare_chat_completion_config(
+        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
+        if response_format:
+            try_modify_message_with_format(messages[-1], response_format)
+            request_config["response_format"] = {"type": "json_object"}
+
+        return request_config
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self._prepare_chat_completion_config(
+            messages, response_format, tools
+        )
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self._prepare_chat_completion_config(
+            messages, response_format, 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],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        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],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
 
-        response = self._client.chat.completions.create(
+        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 stream(self) -> bool: