camel-ai 0.2.23__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.23'
+__version__ = '0.2.24'
 
 __all__ = [
     '__version__',

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/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/societies/role_playing.py

@@ -468,6 +468,42 @@ class RolePlaying:
 
         return init_msg
 
+    async def ainit_chat(
+        self, init_msg_content: Optional[str] = None
+    ) -> BaseMessage:
+        r"""Asynchronously initializes the chat by resetting both of the
+        assistant and user agents. Returns an initial message for the
+        role-playing session.
+
+        Args:
+            init_msg_content (str, optional): A user-specified initial message.
+                Will be sent to the role-playing session as the initial
+                message. (default: :obj:`None`)
+
+        Returns:
+            BaseMessage: A single `BaseMessage` representing the initial
+                message.
+        """
+        # Currently, reset() is synchronous, but if it becomes async in the
+        # future, we can await it here
+        self.assistant_agent.reset()
+        self.user_agent.reset()
+        default_init_msg_content = (
+            "Now start to give me instructions one by one. "
+            "Only reply with Instruction and Input."
+        )
+        if init_msg_content is None:
+            init_msg_content = default_init_msg_content
+
+        # Initialize a message sent by the assistant
+        init_msg = BaseMessage.make_assistant_message(
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
+            content=init_msg_content,
+        )
+
+        return init_msg
+
     def step(
         self,
         assistant_msg: BaseMessage,
@@ -549,3 +585,86 @@ class RolePlaying:
                 info=user_response.info,
             ),
         )
+
+    async def astep(
+        self,
+        assistant_msg: BaseMessage,
+    ) -> Tuple[ChatAgentResponse, ChatAgentResponse]:
+        r"""Asynchronously advances the conversation by taking a message from
+        the assistant, processing it using the user agent, and then processing
+        the resulting message using the assistant agent. Returns a tuple
+        containing the resulting assistant message, whether the assistant
+        agent terminated the conversation, and any additional assistant
+        information, as well as a tuple containing the resulting user message,
+        whether the user agent terminated the conversation, and any additional
+        user information.
+
+        Args:
+            assistant_msg: A `BaseMessage` representing the message from the
+                assistant.
+
+        Returns:
+            Tuple[ChatAgentResponse, ChatAgentResponse]: A tuple containing two
+                ChatAgentResponse: the first struct contains the resulting
+                assistant message, whether the assistant agent terminated the
+                conversation, and any additional assistant information; the
+                second struct contains the resulting user message, whether the
+                user agent terminated the conversation, and any additional user
+                information.
+        """
+        user_response = await self.user_agent.astep(assistant_msg)
+        if user_response.terminated or user_response.msgs is None:
+            return (
+                ChatAgentResponse(msgs=[], terminated=False, info={}),
+                ChatAgentResponse(
+                    msgs=[],
+                    terminated=user_response.terminated,
+                    info=user_response.info,
+                ),
+            )
+        user_msg = self._reduce_message_options(user_response.msgs)
+
+        # To prevent recording the same memory more than once (once in chat
+        # step and once in role play), and the model generates only one
+        # response when multi-response support is enabled.
+        if (
+            'n' in self.user_agent.model_backend.model_config_dict.keys()
+            and self.user_agent.model_backend.model_config_dict['n'] > 1
+        ):
+            self.user_agent.record_message(user_msg)
+
+        assistant_response = await self.assistant_agent.astep(user_msg)
+        if assistant_response.terminated or assistant_response.msgs is None:
+            return (
+                ChatAgentResponse(
+                    msgs=[],
+                    terminated=assistant_response.terminated,
+                    info=assistant_response.info,
+                ),
+                ChatAgentResponse(
+                    msgs=[user_msg], terminated=False, info=user_response.info
+                ),
+            )
+        assistant_msg = self._reduce_message_options(assistant_response.msgs)
+
+        # To prevent recording the same memory more than once (once in chat
+        # step and once in role play), and the model generates only one
+        # response when multi-response support is enabled.
+        if (
+            'n' in self.assistant_agent.model_backend.model_config_dict.keys()
+            and self.assistant_agent.model_backend.model_config_dict['n'] > 1
+        ):
+            self.assistant_agent.record_message(assistant_msg)
+
+        return (
+            ChatAgentResponse(
+                msgs=[assistant_msg],
+                terminated=assistant_response.terminated,
+                info=assistant_response.info,
+            ),
+            ChatAgentResponse(
+                msgs=[user_msg],
+                terminated=user_response.terminated,
+                info=user_response.info,
+            ),
+        )

camel/toolkits/__init__.py

@@ -54,7 +54,10 @@ from .audio_analysis_toolkit import AudioAnalysisToolkit
 from .excel_toolkit import ExcelToolkit
 from .video_analysis_toolkit import VideoAnalysisToolkit
 from .image_analysis_toolkit import ImageAnalysisToolkit
+from .mcp_toolkit import MCPToolkit
 from .web_toolkit import WebToolkit
+from .file_write_toolkit import FileWriteToolkit
+from .terminal_toolkit import TerminalToolkit
 
 
 __all__ = [
@@ -93,9 +96,12 @@ __all__ = [
     'ZapierToolkit',
     'SymPyToolkit',
     'MinerUToolkit',
+    'MCPToolkit',
     'AudioAnalysisToolkit',
     'ExcelToolkit',
     'VideoAnalysisToolkit',
     'ImageAnalysisToolkit',
     'WebToolkit',
+    'FileWriteToolkit',
+    'TerminalToolkit',
 ]

camel/toolkits/file_write_toolkit.py

@@ -0,0 +1,371 @@
+# ========= 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. =========
+
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional, Union
+
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+
+logger = get_logger(__name__)
+
+# Default format when no extension is provided
+DEFAULT_FORMAT = '.md'
+
+
+class FileWriteToolkit(BaseToolkit):
+    r"""A toolkit for creating, writing, and modifying text in files.
+
+    This class provides cross-platform (macOS, Linux, Windows) support for
+    writing to various file formats (Markdown, DOCX, PDF, and plaintext),
+    replacing text in existing files, automatic backups, custom encoding,
+    and enhanced formatting options for specialized formats.
+    """
+
+    def __init__(
+        self,
+        output_dir: str = "./",
+        timeout: Optional[float] = None,
+        default_encoding: str = "utf-8",
+        backup_enabled: bool = True,
+    ) -> None:
+        r"""Initialize the FileWriteToolkit.
+
+        Args:
+            output_dir (str): The default directory for output files.
+                Defaults to the current working directory.
+            timeout (Optional[float]): The timeout for the toolkit.
+                (default: :obj: `None`)
+            default_encoding (str): Default character encoding for text
+                operations. (default: :obj: `utf-8`)
+            backup_enabled (bool): Whether to create backups of existing files
+                before overwriting. (default: :obj: `True`)
+        """
+        super().__init__(timeout=timeout)
+        self.output_dir = Path(output_dir).resolve()
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.default_encoding = default_encoding
+        self.backup_enabled = backup_enabled
+        logger.info(
+            f"FileWriteToolkit initialized with output directory"
+            f": {self.output_dir}, encoding: {default_encoding}"
+        )
+
+    def _resolve_filepath(self, file_path: str) -> Path:
+        r"""Convert the given string path to a Path object.
+
+        If the provided path is not absolute, it is made relative to the
+        default output directory.
+
+        Args:
+            file_path (str): The file path to resolve.
+
+        Returns:
+            Path: A fully resolved (absolute) Path object.
+        """
+        path_obj = Path(file_path)
+        if not path_obj.is_absolute():
+            path_obj = self.output_dir / path_obj
+        return path_obj.resolve()
+
+    def _write_text_file(
+        self, file_path: Path, content: str, encoding: str = "utf-8"
+    ) -> None:
+        r"""Write text content to a plaintext file.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The text content to write.
+            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+        """
+        with file_path.open("w", encoding=encoding) as f:
+            f.write(content)
+        logger.debug(f"Wrote text to {file_path} with {encoding} encoding")
+
+    def _create_backup(self, file_path: Path) -> None:
+        r"""Create a backup of the file if it exists and backup is enabled.
+
+        Args:
+            file_path (Path): Path to the file to backup.
+        """
+        import shutil
+
+        if not self.backup_enabled or not file_path.exists():
+            return
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = file_path.parent / f"{file_path.name}.{timestamp}.bak"
+        shutil.copy2(file_path, backup_path)
+        logger.info(f"Created backup at {backup_path}")
+
+    def _write_docx_file(self, file_path: Path, content: str) -> None:
+        r"""Write text content to a DOCX file with default formatting.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The text content to write.
+        """
+        import docx
+
+        # Use default formatting values
+        font_name = 'Calibri'
+        font_size = 11
+        line_spacing = 1.0
+
+        document = docx.Document()
+        style = document.styles['Normal']
+        style.font.name = font_name
+        style.font.size = docx.shared.Pt(font_size)
+        style.paragraph_format.line_spacing = line_spacing
+
+        # Split content into paragraphs and add them
+        for para_text in content.split('\n'):
+            para = document.add_paragraph(para_text)
+            para.style = style
+
+        document.save(str(file_path))
+        logger.debug(f"Wrote DOCX to {file_path} with default formatting")
+
+    def _write_pdf_file(self, file_path: Path, content: str, **kwargs) -> None:
+        r"""Write text content to a PDF file with default formatting.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The text content to write.
+
+        Raises:
+            RuntimeError: If the 'fpdf' library is not installed.
+        """
+        from fpdf import FPDF
+
+        # Use default formatting values
+        font_family = 'Arial'
+        font_size = 12
+        font_style = ''
+        line_height = 10
+        margin = 10
+
+        pdf = FPDF()
+        pdf.set_margins(margin, margin, margin)
+
+        pdf.add_page()
+        pdf.set_font(font_family, style=font_style, size=font_size)
+
+        # Split content into paragraphs and add them
+        for para in content.split('\n'):
+            if para.strip():  # Skip empty paragraphs
+                pdf.multi_cell(0, line_height, para)
+            else:
+                pdf.ln(line_height)  # Add empty line
+
+        pdf.output(str(file_path))
+        logger.debug(f"Wrote PDF to {file_path} with custom formatting")
+
+    def _write_csv_file(
+        self,
+        file_path: Path,
+        content: Union[str, List[List]],
+        encoding: str = "utf-8",
+    ) -> None:
+        r"""Write CSV content to a file.
+
+        Args:
+            file_path (Path): The target file path.
+            content (Union[str, List[List]]): The CSV content as a string or
+                list of lists.
+            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+        """
+        import csv
+
+        with file_path.open("w", encoding=encoding, newline='') as f:
+            if isinstance(content, str):
+                f.write(content)
+            else:
+                writer = csv.writer(f)
+                writer.writerows(content)
+        logger.debug(f"Wrote CSV to {file_path} with {encoding} encoding")
+
+    def _write_json_file(
+        self,
+        file_path: Path,
+        content: str,
+        encoding: str = "utf-8",
+    ) -> None:
+        r"""Write JSON content to a file.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The JSON content as a string.
+            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+        """
+        import json
+
+        with file_path.open("w", encoding=encoding) as f:
+            if isinstance(content, str):
+                try:
+                    # Try parsing as JSON string first
+                    data = json.loads(content)
+                    json.dump(data, f)
+                except json.JSONDecodeError:
+                    # If not valid JSON string, write as is
+                    f.write(content)
+            else:
+                # If not string, dump as JSON
+                json.dump(content, f)
+        logger.debug(f"Wrote JSON to {file_path} with {encoding} encoding")
+
+    def _write_yaml_file(
+        self,
+        file_path: Path,
+        content: str,
+        encoding: str = "utf-8",
+    ) -> None:
+        r"""Write YAML content to a file.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The YAML content as a string.
+            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+        """
+        with file_path.open("w", encoding=encoding) as f:
+            f.write(content)
+        logger.debug(f"Wrote YAML to {file_path} with {encoding} encoding")
+
+    def _write_html_file(
+        self, file_path: Path, content: str, encoding: str = "utf-8"
+    ) -> None:
+        r"""Write text content to an HTML file.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The HTML content to write.
+            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+        """
+        with file_path.open("w", encoding=encoding) as f:
+            f.write(content)
+        logger.debug(f"Wrote HTML to {file_path} with {encoding} encoding")
+
+    def _write_markdown_file(
+        self, file_path: Path, content: str, encoding: str = "utf-8"
+    ) -> None:
+        r"""Write text content to a Markdown file.
+
+        Args:
+            file_path (Path): The target file path.
+            content (str): The Markdown content to write.
+            encoding (str): Character encoding to use. (default: :obj: `utf-8`)
+        """
+        with file_path.open("w", encoding=encoding) as f:
+            f.write(content)
+        logger.debug(f"Wrote Markdown to {file_path} with {encoding} encoding")
+
+    def write_to_file(
+        self,
+        content: Union[str, List[List[str]]],
+        filename: str,
+        encoding: Optional[str] = None,
+    ) -> str:
+        r"""Write the given content to a file.
+
+        If the file exists, it will be overwritten. Supports multiple formats:
+        Markdown (.md, .markdown, default), Plaintext (.txt), CSV (.csv),
+        DOC/DOCX (.doc, .docx), PDF (.pdf), JSON (.json), YAML (.yml, .yaml),
+        and HTML (.html, .htm).
+
+        Args:
+            content (Union[str, List[List[str]]]): The content to write to the
+                file. For all formats, content must be a string or list in the
+                appropriate format.
+            filename (str): The name or path of the file. If a relative path is
+                supplied, it is resolved to self.output_dir.
+            encoding (Optional[str]): The character encoding to use. (default:
+                :obj: `None`)
+
+        Returns:
+            str: A message indicating success or error details.
+        """
+        file_path = self._resolve_filepath(filename)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create backup if file exists
+        self._create_backup(file_path)
+
+        extension = file_path.suffix.lower()
+
+        # If no extension is provided, use the default format
+        if extension == "":
+            file_path = file_path.with_suffix(DEFAULT_FORMAT)
+            extension = DEFAULT_FORMAT
+
+        try:
+            # Get encoding or use default
+            file_encoding = encoding or self.default_encoding
+
+            if extension in [".doc", ".docx"]:
+                self._write_docx_file(file_path, str(content))
+            elif extension == ".pdf":
+                self._write_pdf_file(file_path, str(content))
+            elif extension == ".csv":
+                self._write_csv_file(
+                    file_path, content, encoding=file_encoding
+                )
+            elif extension == ".json":
+                self._write_json_file(
+                    file_path,
+                    content,  # type: ignore[arg-type]
+                    encoding=file_encoding,
+                )
+            elif extension in [".yml", ".yaml"]:
+                self._write_yaml_file(
+                    file_path, str(content), encoding=file_encoding
+                )
+            elif extension in [".html", ".htm"]:
+                self._write_html_file(
+                    file_path, str(content), encoding=file_encoding
+                )
+            elif extension in [".md", ".markdown"]:
+                self._write_markdown_file(
+                    file_path, str(content), encoding=file_encoding
+                )
+            else:
+                # Fallback to simple text writing for unknown or .txt
+                # extensions
+                self._write_text_file(
+                    file_path, str(content), encoding=file_encoding
+                )
+
+            msg = f"Content successfully written to file: {file_path}"
+            logger.info(msg)
+            return msg
+        except Exception as e:
+            error_msg = (
+                f"Error occurred while writing to file {file_path}: {e}"
+            )
+            logger.error(error_msg)
+            return error_msg
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Return a list of FunctionTool objects representing the functions
+        in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects representing
+                the available functions in this toolkit.
+        """
+        return [
+            FunctionTool(self.write_to_file),
+        ]