camel-ai 0.2.23a0__py3-none-any.whl → 0.2.25__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.25'
 
 __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/configs/sglang_config.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Sequence, Union
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 from camel.configs.base_config import BaseConfig
 from camel.types import NOT_GIVEN, NotGiven
@@ -56,10 +56,11 @@ class SGLangConfig(BaseConfig):
             in the chat completion. The total length of input tokens and
             generated tokens is limited by the model's context length.
             (default: :obj:`None`)
-        tools (list[FunctionTool], optional): A list of tools the model may
-            call. Currently, only functions are supported as a tool. Use this
-            to provide a list of functions the model may generate JSON inputs
-            for. A max of 128 functions are supported.
+        tools (list[Dict[str, Any]], optional): A list of tool definitions
+            that the model can dynamically invoke. Each tool should be
+            defined as a dictionary following OpenAI's function calling
+            specification format. For more details, refer to the OpenAI
+            documentation.
     """
 
     stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
@@ -70,6 +71,7 @@ class SGLangConfig(BaseConfig):
     presence_penalty: float = 0.0
     stream: bool = False
     max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    tools: Optional[Union[List[Dict[str, Any]]]] = None
 
 
 SGLANG_API_PARAMS = {param for param in SGLangConfig.model_fields.keys()}

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/interpreters/subprocess_interpreter.py

@@ -12,8 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-import shlex
+import os
 import subprocess
+import sys
 import tempfile
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List
@@ -43,12 +44,14 @@ class SubprocessInterpreter(BaseInterpreter):
             the executed code. (default: :obj:`False`)
         print_stderr (bool, optional): If True, print the standard error of the
             executed code. (default: :obj:`True`)
+        execution_timeout (int, optional): Maximum time in seconds to wait for
+            code execution to complete. (default: :obj:`60`)
     """
 
-    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, str]] = {
-        "python": "python {file_name}",
-        "bash": "bash {file_name}",
-        "r": "Rscript {file_name}",
+    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, Dict[str, str]]] = {
+        "python": {"posix": "python {file_name}", "nt": "python {file_name}"},
+        "bash": {"posix": "bash {file_name}", "nt": "bash {file_name}"},
+        "r": {"posix": "Rscript {file_name}", "nt": "Rscript {file_name}"},
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
@@ -74,10 +77,12 @@ class SubprocessInterpreter(BaseInterpreter):
         require_confirm: bool = True,
         print_stdout: bool = False,
         print_stderr: bool = True,
+        execution_timeout: int = 60,
     ) -> None:
         self.require_confirm = require_confirm
         self.print_stdout = print_stdout
         self.print_stderr = print_stderr
+        self.execution_timeout = execution_timeout
 
     def run_file(
         self,
@@ -94,13 +99,9 @@ class SubprocessInterpreter(BaseInterpreter):
         Returns:
             str: A string containing the captured stdout and stderr of the
                 executed code.
-
-        Raises:
-            RuntimeError: If the provided file path does not point to a file.
-            InterpreterError: If the code type provided is not supported.
         """
         if not file.is_file():
-            raise RuntimeError(f"{file} is not a file.")
+            return f"{file} is not a file."
         code_type = self._check_code_type(code_type)
         if self._CODE_TYPE_MAPPING[code_type] == "python":
             # For Python code, use ast to analyze and modify the code
@@ -108,7 +109,7 @@ class SubprocessInterpreter(BaseInterpreter):
 
             import astor
 
-            with open(file, 'r') as f:
+            with open(file, 'r', encoding='utf-8') as f:
                 source = f.read()
 
             # Parse the source code
@@ -158,34 +159,88 @@ class SubprocessInterpreter(BaseInterpreter):
                     modified_source = astor.to_source(tree)
                     # Create a temporary file with the modified source
                     temp_file = self._create_temp_file(modified_source, "py")
-                    cmd = shlex.split(f"python {temp_file!s}")
-            except SyntaxError:
-                # If parsing fails, run the original file
-                cmd = shlex.split(
-                    self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                        file_name=str(file)
+                    cmd = ["python", str(temp_file)]
+            except (SyntaxError, TypeError, ValueError) as e:
+                logger.warning(f"Failed to parse Python code with AST: {e}")
+                platform_type = 'posix' if os.name != 'nt' else 'nt'
+                cmd_template = self._CODE_EXECUTE_CMD_MAPPING[code_type][
+                    platform_type
+                ]
+                base_cmd = cmd_template.split()[0]
+
+                # Check if command is available
+                if not self._is_command_available(base_cmd):
+                    raise InterpreterError(
+                        f"Command '{base_cmd}' not found. Please ensure it "
+                        f"is installed and available in your PATH."
                     )
-                )
+
+                cmd = [base_cmd, str(file)]
         else:
             # For non-Python code, use standard execution
-            cmd = shlex.split(
-                self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                    file_name=str(file)
+            platform_type = 'posix' if os.name != 'nt' else 'nt'
+            cmd_template = self._CODE_EXECUTE_CMD_MAPPING[code_type][
+                platform_type
+            ]
+            base_cmd = cmd_template.split()[0]  # Get 'python', 'bash', etc.
+
+            # Check if command is available
+            if not self._is_command_available(base_cmd):
+                raise InterpreterError(
+                    f"Command '{base_cmd}' not found. Please ensure it "
+                    f"is installed and available in your PATH."
                 )
-            )
 
-        proc = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-        )
-        stdout, stderr = proc.communicate()
-        return_code = proc.returncode
+            cmd = [base_cmd, str(file)]
+
+        # Get current Python executable's environment
+        env = os.environ.copy()
+
+        # On Windows, ensure we use the correct Python executable path
+        if os.name == 'nt':
+            python_path = os.path.dirname(sys.executable)
+            if 'PATH' in env:
+                env['PATH'] = python_path + os.pathsep + env['PATH']
+            else:
+                env['PATH'] = python_path
+
+        try:
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                shell=False,  # Never use shell=True for security
+            )
+            # Add timeout to prevent hanging processes
+            stdout, stderr = proc.communicate(timeout=self.execution_timeout)
+            return_code = proc.returncode
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout, stderr = proc.communicate()
+            return_code = proc.returncode
+            timeout_msg = (
+                f"Process timed out after {self.execution_timeout} seconds "
+                f"and was terminated."
+            )
+            stderr = f"{stderr}\n{timeout_msg}"
 
         # Clean up temporary file if it was created
-        if (
-            self._CODE_TYPE_MAPPING[code_type] == "python"
-            and 'temp_file' in locals()
-        ):
-            temp_file.unlink()
+        temp_file_to_clean = locals().get('temp_file')
+        if temp_file_to_clean is not None:
+            try:
+                if temp_file_to_clean.exists():
+                    try:
+                        temp_file_to_clean.unlink()
+                    except PermissionError:
+                        # On Windows, files might be locked
+                        logger.warning(
+                            f"Could not delete temp file "
+                            f"{temp_file_to_clean} (may be locked)"
+                        )
+            except Exception as e:
+                logger.warning(f"Failed to cleanup temporary file: {e}")
 
         if self.print_stdout and stdout:
             print("======stdout======")
@@ -240,7 +295,7 @@ class SubprocessInterpreter(BaseInterpreter):
                 "computer: {code}"
             )
             while True:
-                choice = input("Running code? [Y/n]:").lower()
+                choice = input("Running code? [Y/n]:").lower().strip()
                 if choice in ["y", "yes", "ye", ""]:
                     break
                 elif choice in ["no", "n"]:
@@ -249,22 +304,72 @@ class SubprocessInterpreter(BaseInterpreter):
                         "This choice stops the current operation and any "
                         "further code execution."
                     )
-        temp_file_path = self._create_temp_file(
-            code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
-        )
+                else:
+                    print("Please enter 'y' or 'n'.")
+
+        temp_file_path = None
+        temp_dir = None
+        try:
+            temp_file_path = self._create_temp_file(
+                code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
+            )
+            temp_dir = temp_file_path.parent
+            return self.run_file(temp_file_path, code_type)
+        finally:
+            # Clean up temp file and directory
+            try:
+                if temp_file_path and temp_file_path.exists():
+                    try:
+                        temp_file_path.unlink()
+                    except PermissionError:
+                        # On Windows, files might be locked
+                        logger.warning(
+                            f"Could not delete temp file {temp_file_path}"
+                        )
+
+                if temp_dir and temp_dir.exists():
+                    try:
+                        import shutil
+
+                        shutil.rmtree(temp_dir, ignore_errors=True)
+                    except Exception as e:
+                        logger.warning(f"Could not delete temp directory: {e}")
+            except Exception as e:
+                logger.warning(f"Error during cleanup: {e}")
 
-        result = self.run_file(temp_file_path, code_type)
+    def _create_temp_file(self, code: str, extension: str) -> Path:
+        r"""Creates a temporary file with the given code and extension.
 
-        temp_file_path.unlink()
-        return result
+        Args:
+            code (str): The code to write to the temporary file.
+            extension (str): The file extension to use.
 
-    def _create_temp_file(self, code: str, extension: str) -> Path:
-        with tempfile.NamedTemporaryFile(
-            mode="w", delete=False, suffix=f".{extension}"
-        ) as f:
-            f.write(code)
-            name = f.name
-        return Path(name)
+        Returns:
+            Path: The path to the created temporary file.
+        """
+        try:
+            # Create a temporary directory first to ensure we have write
+            # permissions
+            temp_dir = tempfile.mkdtemp()
+            # Create file path with appropriate extension
+            file_path = Path(temp_dir) / f"temp_code.{extension}"
+
+            # Write code to file with appropriate encoding
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(code)
+
+            return file_path
+        except Exception as e:
+            # Clean up temp directory if creation failed
+            if 'temp_dir' in locals():
+                try:
+                    import shutil
+
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                except Exception:
+                    pass
+            logger.error(f"Failed to create temporary file: {e}")
+            raise
 
     def _check_code_type(self, code_type: str) -> str:
         if code_type not in self._CODE_TYPE_MAPPING:
@@ -284,3 +389,39 @@ class SubprocessInterpreter(BaseInterpreter):
         raise RuntimeError(
             "SubprocessInterpreter doesn't support " "`action_space`."
         )
+
+    def _is_command_available(self, command: str) -> bool:
+        r"""Check if a command is available in the system PATH.
+
+        Args:
+            command (str): The command to check.
+
+        Returns:
+            bool: True if the command is available, False otherwise.
+        """
+        if os.name == 'nt':  # Windows
+            # On Windows, use where.exe to find the command
+            try:
+                with open(os.devnull, 'w') as devnull:
+                    subprocess.check_call(
+                        ['where', command],
+                        stdout=devnull,
+                        stderr=devnull,
+                        shell=False,
+                    )
+                return True
+            except subprocess.CalledProcessError:
+                return False
+        else:  # Unix-like systems
+            # On Unix-like systems, use which to find the command
+            try:
+                with open(os.devnull, 'w') as devnull:
+                    subprocess.check_call(
+                        ['which', command],
+                        stdout=devnull,
+                        stderr=devnull,
+                        shell=False,
+                    )
+                return True
+            except subprocess.CalledProcessError:
+                return False

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,
                 )