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

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.23a0'
+__version__ = '0.2.24'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -694,11 +694,18 @@ class ChatAgent(BaseAgent):
                 f"index: {self.model_backend.current_model_index}",
                 exc_info=exc,
             )
-        if not response:
+            error_info = str(exc)
+
+        if not response and self.model_backend.num_models > 1:
             raise ModelProcessingError(
                 "Unable to process messages: none of the provided models "
                 "run succesfully."
             )
+        elif not response:
+            raise ModelProcessingError(
+                f"Unable to process messages: the only provided model "
+                f"did not run succesfully. Error: {error_info}"
+            )
 
         logger.info(
             f"Model {self.model_backend.model_type}, "
@@ -732,11 +739,18 @@ class ChatAgent(BaseAgent):
                 f"index: {self.model_backend.current_model_index}",
                 exc_info=exc,
             )
-        if not response:
+            error_info = str(exc)
+
+        if not response and self.model_backend.num_models > 1:
             raise ModelProcessingError(
                 "Unable to process messages: none of the provided models "
                 "run succesfully."
             )
+        elif not response:
+            raise ModelProcessingError(
+                f"Unable to process messages: the only provided model "
+                f"did not run succesfully. Error: {error_info}"
+            )
 
         logger.info(
             f"Model {self.model_backend.model_type}, "

camel/configs/anthropic_config.py

@@ -23,23 +23,24 @@ class AnthropicConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     Anthropic API.
 
-    See: https://docs.anthropic.com/claude/reference/complete_post
+    See: https://docs.anthropic.com/en/api/messages
     Args:
         max_tokens (int, optional): The maximum number of tokens to
             generate before stopping. Note that Anthropic models may stop
             before reaching this maximum. This parameter only specifies the
             absolute maximum number of tokens to generate.
             (default: :obj:`8192`)
-        stop_sequences (List[str], optional): Sequences that will cause the
-            model to stop generating completion text. Anthropic models stop
-            on "\n\nHuman:", and may include additional built-in stop sequences
-            in the future. By providing the stop_sequences parameter, you may
-            include additional strings that will cause the model to stop
-            generating. (default: :obj:`[]`)
+        stop_sequences (List[str], optional): Custom text sequences that will
+            cause the model to stop generating. The models will normally stop
+            when they have naturally completed their turn. If the model
+            encounters one of these custom sequences, the response will be
+            terminated and the stop_reason will be "stop_sequence".
+            (default: :obj:`[]`)
         temperature (float, optional): Amount of randomness injected into the
             response. Defaults to 1. Ranges from 0 to 1. Use temp closer to 0
             for analytical / multiple choice, and closer to 1 for creative
-            and generative tasks. (default: :obj:`1`)
+            and generative tasks. Note that even with temperature of 0.0, the
+            results will not be fully deterministic. (default: :obj:`1`)
         top_p (float, optional): Use nucleus sampling. In nucleus sampling, we
             compute the cumulative distribution over all the options for each
             subsequent token in decreasing probability order and cut it off
@@ -49,9 +50,20 @@ class AnthropicConfig(BaseConfig):
         top_k (int, optional): Only sample from the top K options for each
             subsequent token. Used to remove "long tail" low probability
             responses. (default: :obj:`5`)
-        metadata: An object describing metadata about the request.
         stream (bool, optional): Whether to incrementally stream the response
             using server-sent events. (default: :obj:`False`)
+        metadata (Union[dict, NotGiven], optional): An object describing
+            metadata about the request. Can include user_id as an external
+            identifier for the user associated with the request.
+            (default: :obj:`NotGiven()`)
+        thinking (Union[dict, NotGiven], optional): Configuration for enabling
+            Claude's extended thinking. When enabled, responses include
+            thinking content blocks showing Claude's thinking process.
+            (default: :obj:`NotGiven()`)
+        tool_choice (Union[dict, NotGiven], optional): How the model should
+            use the provided tools. The model can use a specific tool, any
+            available tool, decide by itself, or not use tools at all.
+            (default: :obj:`NotGiven()`)
     """
 
     max_tokens: int = 8192
@@ -60,11 +72,33 @@ class AnthropicConfig(BaseConfig):
     top_p: Union[float, NotGiven] = 0.7
     top_k: Union[int, NotGiven] = 5
     stream: bool = False
+    metadata: Union[dict, NotGiven] = NotGiven()
+    thinking: Union[dict, NotGiven] = NotGiven()
+    tool_choice: Union[dict, NotGiven] = NotGiven()
 
     def as_dict(self) -> dict[str, Any]:
         config_dict = super().as_dict()
-        if "tools" in config_dict:
-            del config_dict["tools"]  # TODO: Support tool calling.
+        # Create a list of keys to remove to avoid modifying dict
+        keys_to_remove = [
+            key
+            for key, value in config_dict.items()
+            if isinstance(value, NotGiven)
+        ]
+
+        for key in keys_to_remove:
+            del config_dict[key]
+
+        # remove some keys if thinking is enabled
+        thinking_enabled = (
+            not isinstance(self.thinking, NotGiven)
+            and self.thinking["type"] == "enabled"
+        )
+        if thinking_enabled:
+            # `top_p`, `top_k`, `temperature` must be unset when thinking is
+            # enabled.
+            config_dict.pop("top_k", None)
+            config_dict.pop("top_p", None)
+            config_dict.pop("temperature", None)
         return config_dict
 
 

camel/datagen/self_improving_cot.py

@@ -161,13 +161,13 @@ class SelfImprovingCoTPipeline:
         # Initialize output file with empty results if path is specified
         if self.output_path:
             with open(self.output_path, 'w') as f:
-                json.dump({'traces': []}, f, indent=2)
+                json.dump({'traces': []}, f, indent=2, ensure_ascii=False)
         self.lock = threading.Lock()
 
     def safe_write_json(self, file_path, data):
         temp_path = file_path + ".tmp"
         with open(temp_path, "w") as f:
-            json.dump(data, f, indent=2)
+            json.dump(data, f, indent=2, ensure_ascii=False)
         os.replace(temp_path, file_path)
 
     def clean_json(self, data):

camel/datagen/self_instruct/self_instruct.py

@@ -15,16 +15,20 @@
 import json
 import os
 import random
+import time
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
 from camel.agents import ChatAgent
+from camel.logger import get_logger
 
 from .filter import RougeSimilarityFilter
 from .filter.instruction_filter import InstructionFilter
 from .templates import SelfInstructTemplates
 
+logger = get_logger(__name__)
+
 
 class SelfInstructPipeline:
     r"""A pipeline to generate and manage machine-generated instructions for
@@ -210,18 +214,28 @@ class SelfInstructPipeline:
             )
             return structured_response.answer
         except ValueError as e:
-            print(f"Error parsing agent response: {e}")
+            logger.error(f"Error parsing agent response: {e}")
             return False
 
     def generate_machine_instances(self):
         r"""Generate instances for each machine task based on its
         classification status.
         """
+        logger.info(
+            f"Starting output generation: target {len(self.machine_tasks)} "
+            f"instructions"
+        )
+        attempt_count = 0
         for instruction in self.machine_tasks:
             instance = self.generate_machine_instance(
                 instruction['instruction'], instruction['is_classification']
             )
             instruction['instances'] = instance
+            attempt_count += 1
+            logger.info(
+                f"Attempt[Output]: Progress {attempt_count}/"
+                f"{len(self.machine_tasks)} instructions"
+            )
 
     def generate_machine_instance(
         self, instruction: str, classification: bool
@@ -368,11 +382,30 @@ class SelfInstructPipeline:
         with open(self.data_output_path, 'w') as f:
             json.dump(self.machine_tasks, f, indent=4, ensure_ascii=False)
 
-    def generate(self):
+    def generate(self, timeout_minutes=600):
         r"""Execute the entire pipeline to generate machine instructions
         and instances.
+
+        Args:
+            timeout_minutes (int): Maximum time in minutes to run the
+                generation process before timing out. (default: :obj:`600`)
         """
+        start_time = time.time()
+        timeout_seconds = timeout_minutes * 60
+        logger.info(
+            f"Starting instruction generation: target "
+            f"{self.num_machine_instructions} instructions"
+        )
         while len(self.machine_tasks) < self.num_machine_instructions:
+            # Check for timeout
+            elapsed = time.time() - start_time
+            if elapsed > timeout_seconds:
+                logger.info(
+                    f"Generation timed out after {elapsed / 60:.1f} minutes. "
+                    f"Generated {len(self.machine_tasks)}/"
+                    f"{self.num_machine_instructions} instructions."
+                )
+                break
             prompt, instruction = self.generate_machine_instruction()
             existing_instructions = [
                 t["instruction"] for t in self.human_tasks
@@ -389,6 +422,17 @@ class SelfInstructPipeline:
                     ),
                 }
                 self.machine_tasks.append(instruction_dict)
+                logger.info(
+                    f"Attempt[Instruction]: Progress "
+                    f"{len(self.machine_tasks)}/"
+                    f"{self.num_machine_instructions} "
+                    f"instructions"
+                )
+            else:
+                logger.warning(
+                    f"Instruction failed filters. Skipping instruction: "
+                    f"{instruction}"
+                )
         self.generate_machine_instances()
         self.construct_data()
 

camel/models/__init__.py

@@ -14,6 +14,7 @@
 from .aiml_model import AIMLModel
 from .anthropic_model import AnthropicModel
 from .azure_openai_model import AzureOpenAIModel
+from .base_audio_model import BaseAudioModel
 from .base_model import BaseModelBackend
 from .cohere_model import CohereModel
 from .deepseek_model import DeepSeekModel
@@ -74,4 +75,5 @@ __all__ = [
     'InternLMModel',
     'MoonshotModel',
     'AIMLModel',
+    'BaseAudioModel',
 ]

camel/models/anthropic_model.py

@@ -84,7 +84,11 @@ class AnthropicModel(BaseModelBackend):
                     index=0,
                     message={
                         "role": "assistant",
-                        "content": response.content[0].text,
+                        "content": next(
+                            content.text
+                            for content in response.content
+                            if content.type == "text"
+                        ),
                     },
                     finish_reason=response.stop_reason,
                 )

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/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/model_manager.py

@@ -117,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.

camel/models/openai_audio_models.py

@@ -11,15 +11,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import base64
 import os
 from typing import Any, List, Optional, Union
 
 from openai import AsyncOpenAI, OpenAI, _legacy_response
 
+from camel.models.base_audio_model import BaseAudioModel
 from camel.types import AudioModelType, VoiceType
 
 
-class OpenAIAudioModels:
+class OpenAIAudioModels(BaseAudioModel):
     r"""Provides access to OpenAI's Text-to-Speech (TTS) and Speech_to_Text
     (STT) models."""
 
@@ -29,6 +31,7 @@ class OpenAIAudioModels:
         url: Optional[str] = None,
     ) -> None:
         r"""Initialize an instance of OpenAI."""
+        super().__init__(api_key, url)
         self._url = url or os.environ.get("OPENAI_API_BASE_URL")
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self._client = OpenAI(
@@ -47,6 +50,7 @@ class OpenAIAudioModels:
     def text_to_speech(
         self,
         input: str,
+        *,
         model_type: AudioModelType = AudioModelType.TTS_1,
         voice: VoiceType = VoiceType.ALLOY,
         storage_path: Optional[str] = None,
@@ -111,6 +115,8 @@ class OpenAIAudioModels:
                             new_storage_path = (
                                 f"{file_name}_{chunk_index}{file_extension}"
                             )
+                            # Ensure directory exists
+                            self._ensure_directory_exists(new_storage_path)
                             response.write_to_file(new_storage_path)
                             chunk_index += 1
                         except Exception as e:
@@ -131,6 +137,8 @@ class OpenAIAudioModels:
 
             if storage_path:
                 try:
+                    # Ensure directory exists
+                    self._ensure_directory_exists(storage_path)
                     response.write_to_file(storage_path)
                 except Exception as e:
                     raise Exception("Error during write the file") from e
@@ -263,3 +271,74 @@ class OpenAIAudioModels:
                     return transcription.text
         except Exception as e:
             raise Exception("Error during STT API call") from e
+
+    def audio_question_answering(
+        self,
+        audio_file_path: str,
+        question: str,
+        model: str = "gpt-4o-mini-audio-preview",
+        **kwargs: Any,
+    ) -> str:
+        r"""Answer a question directly using the audio content.
+
+        Args:
+            audio_file_path (str): The path to the audio file.
+            question (str): The question to ask about the audio content.
+            model (str, optional): The model to use for audio question
+                answering. (default: :obj:`"gpt-4o-mini-audio-preview"`)
+            **kwargs (Any): Extra keyword arguments passed to the chat
+                completions API.
+
+        Returns:
+            str: The model's response to the question.
+
+        Raises:
+            Exception: If there's an error during the API call.
+        """
+        try:
+            # Read and encode the audio file
+            with open(audio_file_path, "rb") as audio_file:
+                audio_data = audio_file.read()
+
+            encoded_string = base64.b64encode(audio_data).decode('utf-8')
+
+            # Get file format
+            file_suffix = os.path.splitext(audio_file_path)[1]
+            file_format = file_suffix[1:].lower()
+
+            # Prepare the prompt
+            text_prompt = "Answer the following question based on the "
+            f"given audio information:\n\n{question}"
+
+            # Call the OpenAI API
+            completion = self._client.chat.completions.create(
+                model=model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a helpful assistant "
+                        "specializing in audio analysis.",
+                    },
+                    {  # type: ignore[misc, list-item]
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": text_prompt},
+                            {
+                                "type": "input_audio",
+                                "input_audio": {
+                                    "data": encoded_string,
+                                    "format": file_format,
+                                },
+                            },
+                        ],
+                    },
+                ],
+                **kwargs,
+            )
+
+            response = str(completion.choices[0].message.content)
+            return response
+        except Exception as e:
+            raise Exception(
+                "Error during audio question answering API call"
+            ) from e