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

camel/models/openai_model.py

@@ -13,9 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
 import warnings
-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 OPENAI_API_PARAMS, ChatGPTConfig
 from camel.messages import OpenAIMessage
@@ -31,6 +32,16 @@ from camel.utils import (
     api_keys_required,
 )
 
+UNSUPPORTED_PARAMS = {
+    "temperature",
+    "top_p",
+    "presence_penalty",
+    "frequency_penalty",
+    "logprobs",
+    "top_logprobs",
+    "logit_bias",
+}
+
 
 class OpenAIModel(BaseModelBackend):
     r"""OpenAI API in a unified BaseModelBackend interface.
@@ -68,15 +79,45 @@ class OpenAIModel(BaseModelBackend):
             model_config_dict = ChatGPTConfig().as_dict()
         api_key = api_key or os.environ.get("OPENAI_API_KEY")
         url = url or os.environ.get("OPENAI_API_BASE_URL")
+
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
+
         self._client = OpenAI(
             timeout=180,
             max_retries=3,
             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,
+        )
+
+    def _sanitize_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:
+        """Sanitize the model configuration for O1 models."""
+
+        if self.model_type in [
+            ModelType.O1,
+            ModelType.O1_MINI,
+            ModelType.O1_PREVIEW,
+            ModelType.O3_MINI,
+        ]:
+            warnings.warn(
+                "Warning: You are using an O1 model (O1_MINI or O1_PREVIEW), "
+                "which has certain limitations, reference: "
+                "`https://platform.openai.com/docs/guides/reasoning`.",
+                UserWarning,
+            )
+            return {
+                k: v
+                for k, v in config_dict.items()
+                if k not in UNSUPPORTED_PARAMS
+            }
+        return config_dict
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -90,70 +131,141 @@ class OpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
-    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.
 
         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.
         """
-        # o1-preview and o1-mini have Beta limitations
-        # reference: https://platform.openai.com/docs/guides/reasoning
-        if self.model_type in [
-            ModelType.O1,
-            ModelType.O1_MINI,
-            ModelType.O1_PREVIEW,
-            ModelType.O3_MINI,
-        ]:
-            warnings.warn(
-                "Warning: You are using an O1 model (O1_MINI or O1_PREVIEW), "
-                "which has certain limitations, reference: "
-                "`https://platform.openai.com/docs/guides/reasoning`.",
-                UserWarning,
-            )
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
-            # Check and remove unsupported parameters and reset the fixed
-            # parameters
-            unsupported_keys = [
-                "temperature",
-                "top_p",
-                "presence_penalty",
-                "frequency_penalty",
-                "logprobs",
-                "top_logprobs",
-                "logit_bias",
-            ]
-            for key in unsupported_keys:
-                if key in self.model_config_dict:
-                    del self.model_config_dict[key]
-
-        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,
-            )
+    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
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        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:
+            request_config["tools"] = tools
+
+        request_config = self._sanitize_config(request_config)
+
+        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:
+            request_config["tools"] = tools
+
+        request_config = self._sanitize_config(request_config)
+
+        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
+
+        request_config = self._sanitize_config(request_config)
+
+        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
 
-            return self._to_chat_completion(response)
+        request_config = self._sanitize_config(request_config)
 
-        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
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/models/qwen_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 QWEN_API_PARAMS, QwenConfig
 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,
@@ -81,10 +83,46 @@ class QwenModel(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 Qwen 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 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 Qwen chat completion.
 
@@ -97,13 +135,32 @@ class QwenModel(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
 
+    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
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.

camel/models/reka_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 TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 from camel.configs import REKA_API_PARAMS, RekaConfig
 from camel.messages import OpenAIMessage
@@ -70,7 +72,7 @@ class RekaModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from reka.client import Reka
+        from reka.client import AsyncReka, Reka
 
         if model_config_dict is None:
             model_config_dict = RekaConfig().as_dict()
@@ -80,6 +82,9 @@ class RekaModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = Reka(api_key=self._api_key, base_url=self._url)
+        self._async_client = AsyncReka(
+            api_key=self._api_key, base_url=self._url
+        )
 
     def _convert_reka_to_openai_response(
         self, response: 'ChatResponse'
@@ -117,6 +122,8 @@ class RekaModel(BaseModelBackend):
     def _convert_openai_to_reka_messages(
         self,
         messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[str]] = None,
     ) -> List["ChatMessage"]:
         r"""Converts OpenAI API messages to Reka API messages.
 
@@ -173,9 +180,52 @@ class RekaModel(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,
+    ) -> ChatCompletion:
+        r"""Runs inference of Mistral chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            ChatCompletion.
+        """
+        reka_messages = self._convert_openai_to_reka_messages(messages)
+
+        response = await self._async_client.chat.create(
+            messages=reka_messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+
+        openai_response = self._convert_reka_to_openai_response(response)
+
+        # Add AgentOps LLM Event tracking
+        if LLMEvent:
+            llm_event = LLMEvent(
+                thread_id=openai_response.id,
+                prompt=" ".join(
+                    [message.get("content") for message in messages]  # type: ignore[misc]
+                ),
+                prompt_tokens=openai_response.usage.input_tokens,  # type: ignore[union-attr]
+                completion=openai_response.choices[0].message.content,
+                completion_tokens=openai_response.usage.output_tokens,  # type: ignore[union-attr]
+                model=self.model_type,
+            )
+            record(llm_event)
+
+        return openai_response
+
+    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.
 

camel/models/samba_model.py

@@ -15,10 +15,11 @@ import json
 import os
 import time
 import uuid
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
 import httpx
-from openai import OpenAI, Stream
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import (
     SAMBA_CLOUD_API_PARAMS,
@@ -105,6 +106,12 @@ class SambaModel(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,
+            )
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -148,8 +155,35 @@ class SambaModel(BaseModelBackend):
                 " SambaNova service"
             )
 
-    def run(  # type: ignore[misc]
-        self, messages: List[OpenAIMessage]
+    async def _arun(  # type: ignore[misc]
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs SambaNova's service.
+
+        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.
+        """
+        if "tools" in self.model_config_dict:
+            del self.model_config_dict["tools"]
+        if self.model_config_dict.get("stream") is True:
+            return await self._arun_streaming(messages)
+        else:
+            return await self._arun_non_streaming(messages)
+
+    def _run(  # type: ignore[misc]
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
         r"""Runs SambaNova's service.
 
@@ -398,3 +432,174 @@ class SambaModel(BaseModelBackend):
             bool: Whether the model is in stream mode.
         """
         return self.model_config_dict.get('stream', False)
+
+    async def _arun_streaming(
+        self, messages: List[OpenAIMessage]
+    ) -> AsyncStream[ChatCompletionChunk]:
+        r"""Handles streaming inference with SambaNova's API.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages representing the
+                chat history in OpenAI API format.
+
+        Returns:
+            AsyncStream[ChatCompletionChunk]: A generator yielding
+                `ChatCompletionChunk` objects as they are received from the
+                API.
+
+        Raises:
+            RuntimeError: If the HTTP request fails.
+            ValueError: If the API doesn't support stream mode.
+        """
+        # Handle SambaNova's Cloud API
+        if self._url == "https://api.sambanova.ai/v1":
+            response = await self._async_client.chat.completions.create(
+                messages=messages,
+                model=self.model_type,
+                **self.model_config_dict,
+            )
+
+            # Add AgentOps LLM Event tracking
+            if LLMEvent:
+                llm_event = LLMEvent(
+                    thread_id=response.id,
+                    prompt=" ".join(
+                        [message.get("content") for message in messages]  # type: ignore[misc]
+                    ),
+                    prompt_tokens=response.usage.prompt_tokens,  # type: ignore[union-attr]
+                    completion=response.choices[0].message.content,
+                    completion_tokens=response.usage.completion_tokens,  # type: ignore[union-attr]
+                    model=self.model_type,
+                )
+                record(llm_event)
+
+            return response
+
+        elif self._url == "https://sambaverse.sambanova.ai/api/predict":
+            raise ValueError(
+                "https://sambaverse.sambanova.ai/api/predict doesn't support"
+                " stream mode"
+            )
+        raise RuntimeError(f"Unknown URL: {self._url}")
+
+    async def _arun_non_streaming(
+        self, messages: List[OpenAIMessage]
+    ) -> ChatCompletion:
+        r"""Handles non-streaming inference with SambaNova's API.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages representing the
+                message in OpenAI API format.
+
+        Returns:
+            ChatCompletion: A `ChatCompletion` object containing the complete
+                response from the API.
+
+        Raises:
+            RuntimeError: If the HTTP request fails.
+            ValueError: If the JSON response cannot be decoded or is missing
+                expected data.
+        """
+        # Handle SambaNova's Cloud API
+        if self._url == "https://api.sambanova.ai/v1":
+            response = await self._async_client.chat.completions.create(
+                messages=messages,
+                model=self.model_type,
+                **self.model_config_dict,
+            )
+
+            # Add AgentOps LLM Event tracking
+            if LLMEvent:
+                llm_event = LLMEvent(
+                    thread_id=response.id,
+                    prompt=" ".join(
+                        [message.get("content") for message in messages]  # type: ignore[misc]
+                    ),
+                    prompt_tokens=response.usage.prompt_tokens,  # type: ignore[union-attr]
+                    completion=response.choices[0].message.content,
+                    completion_tokens=response.usage.completion_tokens,  # type: ignore[union-attr]
+                    model=self.model_type,
+                )
+                record(llm_event)
+
+            return response
+
+        # Handle SambaNova's Sambaverse API
+        else:
+            headers = {
+                "Content-Type": "application/json",
+                "key": str(self._api_key),
+                "modelName": self.model_type,
+            }
+
+            data = {
+                "instance": json.dumps(
+                    {
+                        "conversation_id": str(uuid.uuid4()),
+                        "messages": messages,
+                    }
+                ),
+                "params": {
+                    "do_sample": {"type": "bool", "value": "true"},
+                    "max_tokens_to_generate": {
+                        "type": "int",
+                        "value": str(self.model_config_dict.get("max_tokens")),
+                    },
+                    "process_prompt": {"type": "bool", "value": "true"},
+                    "repetition_penalty": {
+                        "type": "float",
+                        "value": str(
+                            self.model_config_dict.get("repetition_penalty")
+                        ),
+                    },
+                    "return_token_count_only": {
+                        "type": "bool",
+                        "value": "false",
+                    },
+                    "select_expert": {
+                        "type": "str",
+                        "value": self.model_type.split("/")[1],
+                    },
+                    "stop_sequences": {
+                        "type": "str",
+                        "value": self.model_config_dict.get("stop_sequences"),
+                    },
+                    "temperature": {
+                        "type": "float",
+                        "value": str(
+                            self.model_config_dict.get("temperature")
+                        ),
+                    },
+                    "top_k": {
+                        "type": "int",
+                        "value": str(self.model_config_dict.get("top_k")),
+                    },
+                    "top_p": {
+                        "type": "float",
+                        "value": str(self.model_config_dict.get("top_p")),
+                    },
+                },
+            }
+
+            try:
+                # Send the request and handle the response
+                with httpx.Client() as client:
+                    response = client.post(
+                        self._url,  # type: ignore[arg-type]
+                        headers=headers,
+                        json=data,
+                    )
+
+                raw_text = response.text
+                # Split the string into two dictionaries
+                dicts = raw_text.split("}\n{")
+
+                # Keep only the last dictionary
+                last_dict = "{" + dicts[-1]
+
+                # Parse the dictionary
+                last_dict = json.loads(last_dict)
+                return self._sambaverse_to_openai_response(last_dict)  # type: ignore[arg-type]
+
+            except httpx.HTTPStatusError:
+                raise RuntimeError(f"HTTP request failed: {raw_text}")