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

camel/models/anthropic_model.py

@@ -12,7 +12,9 @@
 # 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 pydantic import BaseModel
 
 from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
 from camel.messages import OpenAIMessage
@@ -59,7 +61,7 @@ class AnthropicModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from anthropic import Anthropic
+        from anthropic import Anthropic, AsyncAnthropic
 
         if model_config_dict is None:
             model_config_dict = AnthropicConfig().as_dict()
@@ -69,6 +71,9 @@ class AnthropicModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self.client = Anthropic(api_key=self._api_key, base_url=self._url)
+        self.async_client = AsyncAnthropic(
+            api_key=self._api_key, base_url=self._url
+        )
 
     def _convert_response_from_anthropic_to_openai(self, response):
         # openai ^1.0.0 format, reference openai/types/chat/chat_completion.py
@@ -102,9 +107,11 @@ class AnthropicModel(BaseModelBackend):
             self._token_counter = AnthropicTokenCounter(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,
     ):
         r"""Run inference of Anthropic chat completion.
 
@@ -133,6 +140,37 @@ class AnthropicModel(BaseModelBackend):
 
         return response
 
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        r"""Run inference of Anthropic chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            ChatCompletion: Response in the OpenAI API format.
+        """
+        from anthropic import NOT_GIVEN
+
+        if messages[0]["role"] == "system":
+            sys_msg = str(messages.pop(0)["content"])
+        else:
+            sys_msg = NOT_GIVEN  # type: ignore[assignment]
+        response = await self.async_client.messages.create(
+            model=self.model_type,
+            system=sys_msg,
+            messages=messages,  # type: ignore[arg-type]
+            **self.model_config_dict,
+        )
+
+        # format response to openai format
+        return self._convert_response_from_anthropic_to_openai(response)
+
     def check_model_config(self):
         r"""Check whether the model configuration is valid for anthropic
         model backends.

camel/models/azure_openai_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 AzureOpenAI, Stream
+from openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream
+from pydantic import BaseModel
 
 from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
 from camel.messages import OpenAIMessage
@@ -95,6 +96,15 @@ class AzureOpenAIModel(BaseModelBackend):
             max_retries=3,
         )
 
+        self._async_client = AsyncAzureOpenAI(
+            azure_endpoint=str(self._url),
+            azure_deployment=self.azure_deployment_name,
+            api_version=self.api_version,
+            api_key=self._api_key,
+            timeout=180,
+            max_retries=3,
+        )
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -107,9 +117,11 @@ class AzureOpenAIModel(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 Azure OpenAI chat completion.
 
@@ -129,6 +141,30 @@ class AzureOpenAIModel(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]]:
+        r"""Runs inference of Azure OpenAI 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.
+        """
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **self.model_config_dict,
+        )
+        return response
+
     def check_model_config(self):
         r"""Check whether the model configuration contains any
         unexpected arguments to Azure OpenAI API.

camel/models/base_model.py

@@ -14,9 +14,10 @@
 import abc
 import re
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, 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.types import (
@@ -102,7 +103,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self, messages: List[OpenAIMessage]
     ) -> List[OpenAIMessage]:
         r"""Preprocess messages before sending to model API.
-        Removes thinking content and other model-specific preprocessing.
+        Removes thinking content from assistant and user messages.
 
         Args:
             messages (List[OpenAIMessage]): Original messages
@@ -110,39 +111,113 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         Returns:
             List[OpenAIMessage]: Preprocessed messages
         """
-        # Remove thinking content from messages before sending to API
-        # This ensures only the final response is sent, excluding
-        # intermediate thought processes
-        return [
-            {  # type: ignore[misc]
-                **msg,
-                'content': re.sub(
+
+        def should_process_thinking(msg: OpenAIMessage) -> bool:
+            # Only process thinking content for assistant and user messages
+            return msg['role'] in ['assistant', 'user'] and isinstance(
+                msg['content'], str
+            )
+
+        def remove_thinking(content: str) -> str:
+            # Only remove thinking content if the tags are present
+            if '<think>' in content and '</think>' in content:
+                return re.sub(
                     r'<think>.*?</think>',
                     '',
-                    msg['content'],  # type: ignore[arg-type]
+                    content,
                     flags=re.DOTALL,
-                ).strip(),
+                ).strip()
+            return content
+
+        return [
+            {  # type: ignore[misc]
+                **msg,
+                'content': (
+                    remove_thinking(msg['content'])  # type: ignore[arg-type]
+                    if should_process_thinking(msg)
+                    else msg['content']
+                ),
             }
             for msg in messages
         ]
 
     @abstractmethod
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        pass
+
+    @abstractmethod
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        pass
+
     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 the query to the backend model.
 
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The response format
+                to use for the model. (default: :obj:`None`)
+            tools (Optional[List[Tool]]): The schema of tools to use for the
+                model for this request. Will override the tools specified in
+                the model configuration (but not change the configuration).
+                (default: :obj:`None`)
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        pass
+        # None -> use default tools
+        if tools is None:
+            tools = self.model_config_dict.get("tools", None)
+        # Empty -> use no tools
+        elif not tools:
+            tools = None
+        return self._run(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 the query to the backend model asynchronously.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The response format
+                to use for the model. (default: :obj:`None`)
+            tools (Optional[List[Tool]]): The schema of tools to use for the
+                model for this request. Will override the tools specified in
+                the model configuration (but not change the configuration).
+                (default: :obj:`None`)
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        if tools is None:
+            tools = self.model_config_dict.get("tools", None)
+        elif not tools:
+            tools = None
+        return await self._arun(messages, response_format, tools)
 
     @abstractmethod
     def check_model_config(self):

camel/models/cohere_model.py

@@ -16,7 +16,9 @@ import json
 import logging
 import os
 import uuid
-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 cohere.types import ChatMessageV2, ChatResponse
@@ -24,6 +26,7 @@ if TYPE_CHECKING:
 from camel.configs import COHERE_API_PARAMS, CohereConfig
 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, ModelType
 from camel.utils import (
     BaseTokenCounter,
@@ -67,6 +70,7 @@ class CohereModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = cohere.ClientV2(api_key=self._api_key)
+        self._async_client = cohere.AsyncClientV2(api_key=self._api_key)
 
     def _to_openai_response(self, response: 'ChatResponse') -> ChatCompletion:
         if response.usage and response.usage.tokens:
@@ -215,7 +219,30 @@ class CohereModel(BaseModelBackend):
             )
         return self._token_counter
 
-    def run(self, messages: List[OpenAIMessage]) -> ChatCompletion:
+    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:
+            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"}
+
+        return request_config
+
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
         r"""Runs inference of Cohere chat completion.
 
         Args:
@@ -226,21 +253,71 @@ class CohereModel(BaseModelBackend):
         """
         from cohere.core.api_error import ApiError
 
-        cohere_messages = self._to_cohere_chatmessage(messages)
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
 
-        # Removing 'strict': True from the dictionary for
-        # cohere client
-        if self.model_config_dict.get('tools') is not None:
-            for tool in self.model_config_dict.get('tools', []):
-                function_dict = tool.get('function', {})
-                if 'strict' in function_dict:
-                    del function_dict['strict']
+        cohere_messages = self._to_cohere_chatmessage(messages)
 
         try:
             response = self._client.chat(
                 messages=cohere_messages,
                 model=self.model_type,
-                **self.model_config_dict,
+                **request_config,
+            )
+        except ApiError as e:
+            logging.error(f"Cohere API Error: {e.status_code}")
+            logging.error(f"Error body: {e.body}")
+            raise
+        except Exception as e:
+            logging.error(f"Unexpected error when calling Cohere API: {e!s}")
+            raise
+
+        openai_response = self._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.prompt_tokens,  # type: ignore[union-attr]
+                completion=openai_response.choices[0].message.content,
+                completion_tokens=openai_response.usage.completion_tokens,  # type: ignore[union-attr]
+                model=self.model_type,
+            )
+            record(llm_event)
+
+        return openai_response
+
+    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 Cohere chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+        Returns:
+            ChatCompletion.
+        """
+        from cohere.core.api_error import ApiError
+
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        cohere_messages = self._to_cohere_chatmessage(messages)
+
+        try:
+            response = await self._async_client.chat(
+                messages=cohere_messages,
+                model=self.model_type,
+                **request_config,
             )
         except ApiError as e:
             logging.error(f"Cohere API Error: {e.status_code}")

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.