camel-ai 0.2.70__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.70'
+__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/role_playing_worker.py

@@ -27,7 +27,7 @@ from camel.societies.workforce.prompts import (
 )
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
-from camel.tasks.task import Task, TaskState, validate_task_content
+from camel.tasks.task import Task, TaskState, is_task_result_insufficient
 
 
 class RolePlayingWorker(Worker):
@@ -178,14 +178,14 @@ class RolePlayingWorker(Worker):
         result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
 
-        if not validate_task_content(task_result.content, task.id):
+        task.result = task_result.content
+
+        if is_task_result_insufficient(task):
             print(
                 f"{Fore.RED}Task {task.id}: Content validation failed - "
                 f"task marked as failed{Fore.RESET}"
             )
             return TaskState.FAILED
 
-        task.result = task_result.content
-
         print(f"Task result: {task.result}\n")
         return TaskState.DONE

camel/societies/workforce/single_agent_worker.py

@@ -26,7 +26,7 @@ from camel.agents import ChatAgent
 from camel.societies.workforce.prompts import PROCESS_TASK_PROMPT
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
-from camel.tasks.task import Task, TaskState, validate_task_content
+from camel.tasks.task import Task, TaskState, is_task_result_insufficient
 
 
 class AgentPool:
@@ -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)
@@ -352,14 +348,14 @@ class SingleAgentWorker(Worker):
         if task_result.failed:
             return TaskState.FAILED
 
-        if not validate_task_content(task_result.content, task.id):
+        task.result = task_result.content
+
+        if is_task_result_insufficient(task):
             print(
                 f"{Fore.RED}Task {task.id}: Content validation failed - "
                 f"task marked as failed{Fore.RESET}"
             )
             return TaskState.FAILED
-
-        task.result = task_result.content
         return TaskState.DONE
 
     async def _listen_to_channel(self):