camel-ai 0.2.22__py3-none-any.whl → 0.2.23__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_audio_model.py

@@ -0,0 +1,92 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+class BaseAudioModel(ABC):
+    r"""Base class for audio models providing Text-to-Speech (TTS) and
+    Speech-to-Text (STT) functionality.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        r"""Initialize an instance of BaseAudioModel.
+
+        Args:
+            api_key (Optional[str]): API key for the audio service. If not
+                provided, will look for an environment variable specific to the
+                implementation.
+            url (Optional[str]): Base URL for the audio API. If not provided,
+                will use a default URL or look for an environment variable
+                specific to the implementation.
+        """
+        self._api_key = api_key
+        self._url = url
+
+    @abstractmethod
+    def text_to_speech(
+        self,
+        input: str,
+        *,
+        storage_path: str,
+        **kwargs: Any,
+    ) -> Any:
+        r"""Convert text to speech.
+
+        Args:
+            input (str): The text to be converted to speech.
+            storage_path (str): The local path to store the
+                generated speech file.
+            **kwargs (Any): Extra kwargs passed to the TTS API.
+
+        Returns:
+            Any: The response from the TTS API, which may vary by
+                implementation.
+        """
+        pass
+
+    @abstractmethod
+    def speech_to_text(
+        self,
+        audio_file_path: str,
+        **kwargs: Any,
+    ) -> str:
+        r"""Convert speech audio to text.
+
+        Args:
+            audio_file_path (str): The audio file path to transcribe.
+            **kwargs (Any): Extra keyword arguments passed to the
+                Speech-to-Text (STT) API.
+
+        Returns:
+            str: The transcribed text.
+        """
+        pass
+
+    def _ensure_directory_exists(self, file_path: str) -> None:
+        r"""Ensure the directory for the given file path exists.
+
+        Args:
+            file_path (str): The file path for which to ensure the directory
+                exists.
+        """
+        directory = os.path.dirname(file_path)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory)

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}")