camel-ai 0.2.71a1__py3-none-any.whl → 0.2.71a2__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.71a1'
+__version__ = '0.2.71a2'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -13,10 +13,12 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 import textwrap
 import threading
+import time
 import uuid
 from collections import defaultdict
 from pathlib import Path
@@ -173,6 +175,11 @@ class ChatAgent(BaseAgent):
         stop_event (Optional[threading.Event], optional): Event to signal
             termination of the agent's operation. When set, the agent will
             terminate its execution. (default: :obj:`None`)
+        mask_tool_output (Optional[bool]): Whether to return a sanitized
+            placeholder instead of the raw tool output. (default: :obj:`False`)
+        pause_event (Optional[asyncio.Event]): Event to signal pause of the
+            agent's operation. When clear, the agent will pause its execution.
+            (default: :obj:`None`)
     """
 
     def __init__(
@@ -206,6 +213,8 @@ class ChatAgent(BaseAgent):
         max_iteration: Optional[int] = None,
         agent_id: Optional[str] = None,
         stop_event: Optional[threading.Event] = None,
+        mask_tool_output: bool = False,
+        pause_event: Optional[asyncio.Event] = None,
     ) -> None:
         if isinstance(model, ModelManager):
             self.model_backend = model
@@ -280,6 +289,9 @@ class ChatAgent(BaseAgent):
         self.response_terminators = response_terminators or []
         self.max_iteration = max_iteration
         self.stop_event = stop_event
+        self.mask_tool_output = mask_tool_output
+        self._secure_result_store: Dict[str, Any] = {}
+        self.pause_event = pause_event
 
     def reset(self):
         r"""Resets the :obj:`ChatAgent` to its initial state."""
@@ -1143,6 +1155,10 @@ class ChatAgent(BaseAgent):
         iteration_count = 0
 
         while True:
+            if self.pause_event is not None and not self.pause_event.is_set():
+                while not self.pause_event.is_set():
+                    time.sleep(0.001)
+
             try:
                 openai_messages, num_tokens = self.memory.get_context()
                 accumulated_context_tokens += num_tokens
@@ -1184,6 +1200,12 @@ class ChatAgent(BaseAgent):
                             external_tool_call_requests = []
                         external_tool_call_requests.append(tool_call_request)
                     else:
+                        if (
+                            self.pause_event is not None
+                            and not self.pause_event.is_set()
+                        ):
+                            while not self.pause_event.is_set():
+                                time.sleep(0.001)
                         tool_call_records.append(
                             self._execute_tool(tool_call_request)
                         )
@@ -1287,6 +1309,8 @@ class ChatAgent(BaseAgent):
         step_token_usage = self._create_token_usage_tracker()
         iteration_count = 0
         while True:
+            if self.pause_event is not None and not self.pause_event.is_set():
+                await self.pause_event.wait()
             try:
                 openai_messages, num_tokens = self.memory.get_context()
                 accumulated_context_tokens += num_tokens
@@ -1328,6 +1352,11 @@ class ChatAgent(BaseAgent):
                             external_tool_call_requests = []
                         external_tool_call_requests.append(tool_call_request)
                     else:
+                        if (
+                            self.pause_event is not None
+                            and not self.pause_event.is_set()
+                        ):
+                            await self.pause_event.wait()
                         tool_call_record = await self._aexecute_tool(
                             tool_call_request
                         )
@@ -1958,14 +1987,27 @@ class ChatAgent(BaseAgent):
         tool_call_id = tool_call_request.tool_call_id
         tool = self._internal_tools[func_name]
         try:
-            result = tool(**args)
+            raw_result = tool(**args)
+            if self.mask_tool_output:
+                self._secure_result_store[tool_call_id] = raw_result
+                result = (
+                    "[The tool has been executed successfully, but the output"
+                    " from the tool is masked. You can move forward]"
+                )
+                mask_flag = True
+            else:
+                result = raw_result
+                mask_flag = False
         except Exception as e:
             # Capture the error message to prevent framework crash
             error_msg = f"Error executing tool '{func_name}': {e!s}"
-            result = {"error": error_msg}
+            result = f"Tool execution failed: {error_msg}"
+            mask_flag = False
             logging.warning(error_msg)
 
-        return self._record_tool_calling(func_name, args, result, tool_call_id)
+        return self._record_tool_calling(
+            func_name, args, result, tool_call_id, mask_output=mask_flag
+        )
 
     async def _aexecute_tool(
         self,
@@ -2015,9 +2057,23 @@ class ChatAgent(BaseAgent):
         args: Dict[str, Any],
         result: Any,
         tool_call_id: str,
+        mask_output: bool = False,
     ):
         r"""Record the tool calling information in the memory, and return the
         tool calling record.
+
+        Args:
+            func_name (str): The name of the tool function called.
+            args (Dict[str, Any]): The arguments passed to the tool.
+            result (Any): The result returned by the tool execution.
+            tool_call_id (str): A unique identifier for the tool call.
+            mask_output (bool, optional): Whether to return a sanitized
+                placeholder instead of the raw tool output.
+                (default: :obj:`False`)
+
+        Returns:
+            ToolCallingRecord: A struct containing information about
+            this tool call.
         """
         assist_msg = FunctionCallingMessage(
             role_name=self.role_name,
@@ -2036,6 +2092,7 @@ class ChatAgent(BaseAgent):
             func_name=func_name,
             result=result,
             tool_call_id=tool_call_id,
+            mask_output=mask_output,
         )
 
         # Use precise timestamps to ensure correct ordering
@@ -2140,6 +2197,7 @@ class ChatAgent(BaseAgent):
             ),
             max_iteration=self.max_iteration,
             stop_event=self.stop_event,
+            pause_event=self.pause_event,
         )
 
         # Copy memory if requested

camel/messages/func_message.py

@@ -47,12 +47,16 @@ class FunctionCallingMessage(BaseMessage):
             (default: :obj:`None`)
         tool_call_id (Optional[str]): The ID of the tool call, if available.
             (default: :obj:`None`)
+        mask_output (Optional[bool]): Whether to return a sanitized placeholder
+            instead of the raw tool output.
+            (default: :obj:`False`)
     """
 
     func_name: Optional[str] = None
     args: Optional[Dict] = None
     result: Optional[Any] = None
     tool_call_id: Optional[str] = None
+    mask_output: Optional[bool] = False
 
     def to_openai_message(
         self,
@@ -105,10 +109,13 @@ class FunctionCallingMessage(BaseMessage):
             # This is a function response
             # TODO: Allow for more flexible setting of tool role,
             #  optionally to be the same as assistant messages
-            content = function_format.format_tool_response(
-                self.func_name,  # type: ignore[arg-type]
-                self.result,  # type: ignore[arg-type]
-            )
+            if self.mask_output:
+                content = "[MASKED]"
+            else:
+                content = function_format.format_tool_response(
+                    self.func_name,  # type: ignore[arg-type]
+                    self.result,  # type: ignore[arg-type]
+                )
             return ShareGPTMessage(from_="tool", value=content)  # type: ignore[call-arg]
 
     def to_openai_assistant_message(self) -> OpenAIAssistantMessage:
@@ -154,10 +161,30 @@ class FunctionCallingMessage(BaseMessage):
                 " due to missing function name."
             )
 
-        result_content = str(self.result)
+        if self.mask_output:
+            result_content = "[MASKED]"
+        else:
+            result_content = str(self.result)
 
         return {
             "role": "tool",
             "content": result_content,
             "tool_call_id": self.tool_call_id or "null",
         }
+
+    def to_dict(self) -> Dict:
+        r"""Converts the message to a dictionary.
+
+        Returns:
+            dict: The converted dictionary.
+        """
+        base = super().to_dict()
+        base["func_name"] = self.func_name
+        if self.args is not None:
+            base["args"] = self.args
+        if self.result is not None:
+            base["result"] = self.result
+        if self.tool_call_id is not None:
+            base["tool_call_id"] = self.tool_call_id
+        base["mask_output"] = self.mask_output
+        return base

camel/societies/workforce/single_agent_worker.py

@@ -43,8 +43,6 @@ class AgentPool:
             (default: :obj:`10`)
         auto_scale (bool): Whether to automatically scale the pool size.
             (default: :obj:`True`)
-        scale_factor (float): Factor by which to scale the pool when needed.
-            (default: :obj:`1.5`)
         idle_timeout (float): Time in seconds after which idle agents are
             removed. (default: :obj:`180.0`)
     """
@@ -55,13 +53,11 @@ class AgentPool:
         initial_size: int = 1,
         max_size: int = 10,
         auto_scale: bool = True,
-        scale_factor: float = 1.5,
         idle_timeout: float = 180.0,  # 3 minutes
     ):
         self.base_agent = base_agent
         self.max_size = max_size
         self.auto_scale = auto_scale
-        self.scale_factor = scale_factor
         self.idle_timeout = idle_timeout
 
         # Pool management
@@ -332,7 +328,7 @@ class SingleAgentWorker(Worker):
         # Store the actual token usage for this specific task
         task.additional_info["token_usage"] = {"total_tokens": total_tokens}
 
-        print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
+        print(f"======\n{Fore.GREEN}Response from {self}:{Fore.RESET}")
 
         try:
             result_dict = json.loads(response.msg.content)

camel/societies/workforce/workforce.py

@@ -395,6 +395,40 @@ class Workforce(BaseNode):
                 "better context continuity during task handoffs."
             )
 
+        # ------------------------------------------------------------------
+        # Helper for propagating pause control to externally supplied agents
+        # ------------------------------------------------------------------
+
+    def _attach_pause_event_to_agent(self, agent: ChatAgent) -> None:
+        r"""Ensure the given ChatAgent shares this workforce's pause_event.
+
+        If the agent already has a different pause_event we overwrite it and
+        emit a debug log (it is unlikely an agent needs multiple independent
+        pause controls once managed by this workforce)."""
+        try:
+            existing_pause_event = getattr(agent, "pause_event", None)
+            if existing_pause_event is not self._pause_event:
+                if existing_pause_event is not None:
+                    logger.debug(
+                        f"Overriding pause_event for agent {agent.agent_id} "
+                        f"(had different pause_event: "
+                        f"{id(existing_pause_event)} "
+                        f"-> {id(self._pause_event)})"
+                    )
+                agent.pause_event = self._pause_event
+        except AttributeError:
+            # Should not happen, but guard against unexpected objects
+            logger.warning(
+                f"Cannot attach pause_event to object {type(agent)} - "
+                f"missing pause_event attribute"
+            )
+
+    def _ensure_pause_event_in_kwargs(self, kwargs: Optional[Dict]) -> Dict:
+        r"""Insert pause_event into kwargs dict for ChatAgent construction."""
+        new_kwargs = dict(kwargs) if kwargs else {}
+        new_kwargs.setdefault("pause_event", self._pause_event)
+        return new_kwargs
+
     def __repr__(self):
         return (
             f"Workforce {self.node_id} ({self.description}) - "
@@ -1138,6 +1172,9 @@ class Workforce(BaseNode):
         Returns:
             Workforce: The workforce node itself.
         """
+        # Ensure the worker agent shares this workforce's pause control
+        self._attach_pause_event_to_agent(worker)
+
         worker_node = SingleAgentWorker(
             description=description,
             worker=worker,
@@ -1184,6 +1221,18 @@ class Workforce(BaseNode):
         Returns:
             Workforce: The workforce node itself.
         """
+        # Ensure provided kwargs carry pause_event so that internally created
+        # ChatAgents (assistant/user/summarizer) inherit it.
+        assistant_agent_kwargs = self._ensure_pause_event_in_kwargs(
+            assistant_agent_kwargs
+        )
+        user_agent_kwargs = self._ensure_pause_event_in_kwargs(
+            user_agent_kwargs
+        )
+        summarize_agent_kwargs = self._ensure_pause_event_in_kwargs(
+            summarize_agent_kwargs
+        )
+
         worker_node = RolePlayingWorker(
             description=description,
             assistant_role_name=assistant_role_name,
@@ -1212,6 +1261,9 @@ class Workforce(BaseNode):
         Returns:
             Workforce: The workforce node itself.
         """
+        # Align child workforce's pause_event with this one for unified
+        # control of worker agents only.
+        workforce._pause_event = self._pause_event
         self._children.append(workforce)
         return self
 
@@ -1245,14 +1297,17 @@ class Workforce(BaseNode):
         # Handle asyncio.Event in a thread-safe way
         if self._loop and not self._loop.is_closed():
             # If we have a loop, use it to set the event safely
-            asyncio.run_coroutine_threadsafe(
-                self._async_reset(), self._loop
-            ).result()
-        else:
             try:
-                self._reset_task = asyncio.create_task(self._async_reset())
-            except RuntimeError:
-                asyncio.run(self._async_reset())
+                asyncio.run_coroutine_threadsafe(
+                    self._async_reset(), self._loop
+                ).result()
+            except RuntimeError as e:
+                logger.warning(f"Failed to reset via existing loop: {e}")
+                # Fallback to direct event manipulation
+                self._pause_event.set()
+        else:
+            # No active loop, directly set the event
+            self._pause_event.set()
 
         if hasattr(self, 'metrics_logger') and self.metrics_logger is not None:
             self.metrics_logger.reset_task_data()
@@ -1656,7 +1711,12 @@ class Workforce(BaseNode):
                 model_config_dict={"temperature": 0},
             )
 
-            return ChatAgent(worker_sys_msg, model=model, tools=function_list)  # type: ignore[arg-type]
+            return ChatAgent(
+                worker_sys_msg,
+                model=model,
+                tools=function_list,  # type: ignore[arg-type]
+                pause_event=self._pause_event,
+            )
 
     async def _get_returned_task(self) -> Optional[Task]:
         r"""Get the task that's published by this node and just get returned

camel/tasks/task.py

@@ -56,7 +56,7 @@ class TaskValidationMode(Enum):
 def validate_task_content(
     content: str,
     task_id: str = "unknown",
-    min_length: int = 5,
+    min_length: int = 1,
     mode: TaskValidationMode = TaskValidationMode.INPUT,
     check_failure_patterns: bool = True,
 ) -> bool:
@@ -69,7 +69,7 @@ def validate_task_content(
         task_id (str): Task ID for logging purposes.
             (default: :obj:`"unknown"`)
         min_length (int): Minimum content length after stripping whitespace.
-            (default: :obj:`5`)
+            (default: :obj:`1`)
         mode (TaskValidationMode): Validation mode - INPUT for task content,
             OUTPUT for task results. (default: :obj:`TaskValidationMode.INPUT`)
         check_failure_patterns (bool): Whether to check for failure indicators

camel/toolkits/craw4ai_toolkit.py

@@ -31,6 +31,16 @@ class Crawl4AIToolkit(BaseToolkit):
         timeout: Optional[float] = None,
     ):
         super().__init__(timeout=timeout)
+        self._client = None
+
+    async def _get_client(self):
+        r"""Get or create the AsyncWebCrawler client."""
+        if self._client is None:
+            from crawl4ai import AsyncWebCrawler
+
+            self._client = AsyncWebCrawler()
+            await self._client.__aenter__()
+        return self._client
 
     async def scrape(self, url: str) -> str:
         r"""Scrapes a webpage and returns its content.
@@ -47,19 +57,29 @@ class Crawl4AIToolkit(BaseToolkit):
             str: The scraped content of the webpage as a string. If the
                 scraping fails, it will return an error message.
         """
-        from crawl4ai import AsyncWebCrawler, CrawlerRunConfig
+        from crawl4ai import CrawlerRunConfig
 
         try:
-            async with AsyncWebCrawler() as client:
-                config = CrawlerRunConfig(
-                    only_text=True,
-                )
-                content = await client.arun(url, crawler_config=config)
-                return str(content.markdown) if content.markdown else ""
+            client = await self._get_client()
+            config = CrawlerRunConfig(
+                only_text=True,
+            )
+            content = await client.arun(url, crawler_config=config)
+            return str(content.markdown) if content.markdown else ""
         except Exception as e:
             logger.error(f"Error scraping {url}: {e}")
             return f"Error scraping {url}: {e}"
 
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit - cleanup the client."""
+        if self._client is not None:
+            await self._client.__aexit__(exc_type, exc_val, exc_tb)
+            self._client = None
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
         functions in the toolkit.

camel/toolkits/file_write_toolkit.py

@@ -146,23 +146,25 @@ class FileWriteToolkit(BaseToolkit):
         document.save(str(file_path))
         logger.debug(f"Wrote DOCX to {file_path} with default formatting")
 
-    @dependencies_required('pylatex', 'fpdf')
+    @dependencies_required('pylatex', 'pymupdf')
     def _write_pdf_file(
-        self, file_path: Path, content: str, use_latex: bool = False
+        self,
+        file_path: Path,
+        title: str,
+        content: str,
+        use_latex: bool = False,
     ) -> None:
         r"""Write text content to a PDF file with default formatting.
 
         Args:
             file_path (Path): The target file path.
+            title (str): The title of the document.
             content (str): The text content to write.
             use_latex (bool): Whether to use LaTeX for rendering. (requires
-                LaTeX toolchain). If False, uses FPDF for simpler PDF
+                LaTeX toolchain). If False, uses PyMuPDF for simpler PDF
                 generation. (default: :obj:`False`)
-
-        Raises:
-            RuntimeError: If the 'pylatex' or 'fpdf' library is not installed
-                when use_latex=True.
         """
+        # TODO: table generation need to be improved
         if use_latex:
             from pylatex import (
                 Command,
@@ -213,30 +215,105 @@ class FileWriteToolkit(BaseToolkit):
 
             logger.info(f"Wrote PDF (with LaTeX) to {file_path}")
         else:
-            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)
+            import pymupdf
+
+            # Create a new PDF document
+            doc = pymupdf.open()
+
+            # Add a page
+            page = doc.new_page()
+
+            # Process the content
+            lines = content.strip().split('\n')
+            document_title = title
+
+            # Create a TextWriter for writing text to the page
+            text_writer = pymupdf.TextWriter(page.rect)
+
+            # Define fonts
+            normal_font = pymupdf.Font(
+                "helv"
+            )  # Standard font with multilingual support
+            bold_font = pymupdf.Font("helv")
+
+            # Start position for text
+            y_pos = 50
+            x_pos = 50
+
+            # Add title
+            text_writer.fill_textbox(
+                pymupdf.Rect(
+                    x_pos, y_pos, page.rect.width - x_pos, y_pos + 30
+                ),
+                document_title,
+                fontsize=16,
+            )
+            y_pos += 40
+
+            # Process content
+            for line in lines:
+                stripped_line = line.strip()
+
+                # Skip empty lines but add some space
+                if not stripped_line:
+                    y_pos += 10
+                    continue
+
+                # Handle headers
+                if stripped_line.startswith('## '):
+                    text_writer.fill_textbox(
+                        pymupdf.Rect(
+                            x_pos, y_pos, page.rect.width - x_pos, y_pos + 20
+                        ),
+                        stripped_line[3:].strip(),
+                        font=bold_font,
+                        fontsize=14,
+                    )
+                    y_pos += 25
+                elif stripped_line.startswith('# '):
+                    text_writer.fill_textbox(
+                        pymupdf.Rect(
+                            x_pos, y_pos, page.rect.width - x_pos, y_pos + 25
+                        ),
+                        stripped_line[2:].strip(),
+                        font=bold_font,
+                        fontsize=16,
+                    )
+                    y_pos += 30
+                # Handle horizontal rule
+                elif stripped_line == '---':
+                    page.draw_line(
+                        pymupdf.Point(x_pos, y_pos + 5),
+                        pymupdf.Point(page.rect.width - x_pos, y_pos + 5),
+                    )
+                    y_pos += 15
+                # Regular text
                 else:
-                    pdf.ln(line_height)  # Add empty line
-
-            pdf.output(str(file_path))
-            logger.debug(f"Wrote PDF to {file_path} with custom formatting")
+                    # Check if we need a new page
+                    if y_pos > page.rect.height - 50:
+                        text_writer.write_text(page)
+                        page = doc.new_page()
+                        text_writer = pymupdf.TextWriter(page.rect)
+                        y_pos = 50
+
+                    # Add text to the current page
+                    text_writer.fill_textbox(
+                        pymupdf.Rect(
+                            x_pos, y_pos, page.rect.width - x_pos, y_pos + 15
+                        ),
+                        stripped_line,
+                        font=normal_font,
+                    )
+                    y_pos += 15
+
+            # Write the accumulated text to the last page
+            text_writer.write_text(page)
+
+            # Save the PDF
+            doc.save(str(file_path))
+            doc.close()
+
+            logger.debug(f"Wrote PDF to {file_path} with PyMuPDF formatting")
 
     def _write_csv_file(
         self,
@@ -338,6 +415,7 @@ class FileWriteToolkit(BaseToolkit):
 
     def write_to_file(
         self,
+        title: str,
         content: Union[str, List[List[str]]],
         filename: str,
         encoding: Optional[str] = None,
@@ -351,6 +429,7 @@ class FileWriteToolkit(BaseToolkit):
         and HTML (.html, .htm).
 
         Args:
+            title (str): The title of the document.
             content (Union[str, List[List[str]]]): The content to write to the
                 file. Content format varies by file type:
                 - Text formats (txt, md, html, yaml): string
@@ -388,7 +467,7 @@ class FileWriteToolkit(BaseToolkit):
                 self._write_docx_file(file_path, str(content))
             elif extension == ".pdf":
                 self._write_pdf_file(
-                    file_path, str(content), use_latex=use_latex
+                    file_path, title, str(content), use_latex=use_latex
                 )
             elif extension == ".csv":
                 self._write_csv_file(