Merge branch 'master' into feat-trigger

Author: fengju0213

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -26,7 +26,7 @@ body:
     attributes:
       label: What version of camel are you using?
       description: Run command `python3 -c 'print(__import__("camel").__version__)'` in your shell and paste the output here.
-      placeholder: E.g., 0.2.83a9
+      placeholder: E.g., 0.2.83a7
     validations:
       required: true
 

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.83a9'
+__version__ = '0.2.83a7'
 
 __all__ = [
     '__version__',

camel/environments/tic_tac_toe.py

@@ -413,6 +413,9 @@ def evaluate_position_for_x(
         Args:
             board (List[str]): The current game board as a list of strings.
             is_x_turn (bool): True if it's X's turn to move, False otherwise.
+            depth (int): Current recursion depth. (default: :obj:`0`)
+            max_depth (int): Maximum recursion depth to prevent stack overflow.
+                (default: :obj:`10`)
 
         Returns:
             float: A float value representing the position evaluation:
@@ -435,14 +438,17 @@ def evaluate_position_for_x(
             return 0.5  # Return draw evaluation at max depth
 
         moves = TicTacToeEnv.available_moves(board)
+        if not moves:
+            return 0.5
+        symbol = "X" if is_x_turn else "O"
         values = []
-        # Create a copy of the board to avoid side effects
+
         for move in moves:
-            board_copy = board.copy()
-            board_copy[move] = "X" if is_x_turn else "O"
+            board[move] = symbol
             value = TicTacToeEnv.evaluate_position_for_x(
-                board_copy, not is_x_turn, depth + 1, max_depth
+                board, not is_x_turn, depth + 1, max_depth
             )
+            board[move] = " "  # undo the move
             values.append(value)
 
         return max(values) if is_x_turn else min(values)

camel/societies/workforce/prompts.py

@@ -340,15 +340,12 @@
 
 **DECISION GUIDELINES:**
 
-**IMPORTANT: You MUST ONLY select from the ENABLED strategies listed above.**
-If a strategy is not in the ENABLED list, you CANNOT use it regardless of the guidelines below.
-
-**Priority Rules (apply ONLY if the strategy is ENABLED):**
-1. Connection/Network Errors → prefer **retry** if enabled
-2. Deep Tasks (depth > 2) → Avoid decompose, prefer **retry** or **replan** if enabled
-3. Worker Skill Mismatch → prefer **reassign** (quality) or **decompose** (failure) if enabled, otherwise use **replan**
-4. Unclear Requirements → prefer **replan** with specifics if enabled
-5. Task Too Complex → prefer **decompose** into subtasks if enabled, otherwise use **replan**
+**Priority Rules:**
+1. Connection/Network Errors → **retry** (almost always)
+2. Deep Tasks (depth > 2) → Avoid decompose, prefer **retry** or **replan**
+3. Worker Skill Mismatch → **reassign** (quality) or **decompose** (failure)
+4. Unclear Requirements → **replan** with specifics
+5. Task Too Complex → **decompose** into subtasks
 
 **RESPONSE FORMAT:**
 {response_format}
@@ -358,7 +355,7 @@
 - No explanations or text outside the JSON structure
 - Ensure all required fields are included
 - Use null for optional fields when not applicable
-- **MANDATORY: The recovery_strategy MUST be one of the ENABLED strategies listed above. Using a disabled strategy will cause an error.**
+- ONLY use strategies listed above as ENABLED
 """
 )
 

camel/societies/workforce/workforce.py

@@ -3862,8 +3862,6 @@ async def _post_task(self, task: Task, assignee_id: str) -> None:
         # Record the start time when a task is posted
         self._task_start_times[task.id] = time.time()
 
-        # Ensure assignee mapping exists for retries and follow-up handling.
-        self._assignees[task.id] = assignee_id
         task.assigned_worker_id = assignee_id
 
         task_started_event = TaskStartedEvent(
@@ -4544,29 +4542,15 @@ async def _handle_failed_task(self, task: Task) -> bool:
             task, for_failure=True, error_message=detailed_error
         )
 
-        # Validate and fallback recovery strategy based on enabled_strategies
-        config_strategies = self.failure_handling_config.enabled_strategies
+        # Fallback to first enabled strategy if no strategy recommended
         if recovery_decision.recovery_strategy is None:
-            # No strategy recommended - use fallback
+            config_strategies = self.failure_handling_config.enabled_strategies
             # config_strategies is None means all enabled, use RETRY as default
             # otherwise use the first enabled strategy from user's config
             if config_strategies is None:
                 recovery_decision.recovery_strategy = RecoveryStrategy.RETRY
             else:
                 recovery_decision.recovery_strategy = config_strategies[0]
-        elif config_strategies is not None:
-            # Strategy recommended - validate it's in enabled list
-            if recovery_decision.recovery_strategy not in config_strategies:
-                # LLM recommended a disabled strategy, use first enabled
-                recommended = recovery_decision.recovery_strategy.value
-                enabled_list = [s.value for s in config_strategies]
-                fallback = config_strategies[0].value
-                logger.warning(
-                    f"Task {task.id}: LLM recommended '{recommended}' "
-                    f"but it's not in enabled_strategies {enabled_list}. "
-                    f"Using '{fallback}' instead."
-                )
-                recovery_decision.recovery_strategy = config_strategies[0]
 
         strategy_str = recovery_decision.recovery_strategy.value
         logger.info(
@@ -5324,12 +5308,11 @@ async def _listen_to_channel(self) -> None:
                                 f"Issues: {', '.join(quality_eval.issues)}"
                             )
 
-                            # Validate and fallback recovery strategy based on
-                            # enabled_strategies
-                            config = self.failure_handling_config
-                            config_strategies = config.enabled_strategies
+                            # Fallback to first enabled strategy if none
+                            # recommended
                             if quality_eval.recovery_strategy is None:
-                                # No strategy recommended - use fallback
+                                config = self.failure_handling_config
+                                config_strategies = config.enabled_strategies
                                 if config_strategies is None:
                                     quality_eval.recovery_strategy = (
                                         RecoveryStrategy.RETRY
@@ -5338,27 +5321,6 @@ async def _listen_to_channel(self) -> None:
                                     quality_eval.recovery_strategy = (
                                         config_strategies[0]
                                     )
-                            elif config_strategies is not None:
-                                # Strategy recommended - validate it's enabled
-                                if (
-                                    quality_eval.recovery_strategy
-                                    not in config_strategies
-                                ):
-                                    # LLM recommended a disabled strategy
-                                    rec = quality_eval.recovery_strategy.value
-                                    enabled = [
-                                        s.value for s in config_strategies
-                                    ]
-                                    fallback = config_strategies[0].value
-                                    logger.warning(
-                                        f"Task {returned_task.id}: LLM "
-                                        f"recommended '{rec}' but it's not in "
-                                        f"enabled_strategies {enabled}. "
-                                        f"Using '{fallback}' instead."
-                                    )
-                                    quality_eval.recovery_strategy = (
-                                        config_strategies[0]
-                                    )
 
                             # Preserve assignee before cleanup - in normal
                             # flow, a task must be assigned before it can fail

camel/toolkits/lark_toolkit.py

@@ -356,72 +356,6 @@ def lark_get_chat_messages(
             logger.error(f"Error getting chat messages: {e}")
             return {"error": f"Error getting chat messages: {e!s}"}
 
-    def lark_send_message(
-        self,
-        receive_id: str,
-        text: str,
-        receive_id_type: Literal[
-            "open_id", "user_id", "union_id", "email", "chat_id"
-        ] = "chat_id",
-    ) -> Dict[str, object]:
-        r"""Sends a message to a user or chat. If send message to
-        a chat, use lark_list_chats to get chat_id first, if send
-        message to a user, need user provide open_id, user_id,
-        union_id or email.
-
-        Args:
-            receive_id (str): The recipient identifier.
-            text (str): The text message content.
-            receive_id_type (str): The recipient ID type. Options:
-                - "open_id"
-                - "user_id"
-                - "union_id"
-                - "email"
-                - "chat_id" (default)
-
-        Returns:
-            Dict[str, object]: A dictionary containing:
-                - message_id: The sent message ID
-                - chat_id: The chat ID the message belongs to
-                - msg_type: Message type (text)
-        """
-        # NOTE: Currently supports plain text messages only.
-        try:
-            url = f"{self._domain}/open-apis/im/v1/messages"
-            headers = self._get_tenant_http_headers()
-            params = {"receive_id_type": receive_id_type}
-            payload = {
-                "receive_id": receive_id,
-                "msg_type": "text",
-                "content": json.dumps({"text": text}),
-            }
-
-            response = requests.post(
-                url, headers=headers, params=params, json=payload, timeout=30
-            )
-            result = response.json()
-
-            if result.get("code") != 0:
-                logger.error(
-                    f"Failed to send message: {result.get('code')} - "
-                    f"{result.get('msg')}"
-                )
-                return {
-                    "error": f"Failed to send message: {result.get('msg')}",
-                    "code": result.get("code"),
-                }
-
-            data = result.get("data", {}) or {}
-            return {
-                "message_id": data.get("message_id"),
-                "chat_id": data.get("chat_id"),
-                "msg_type": data.get("msg_type"),
-            }
-
-        except Exception as e:
-            logger.error(f"Error sending message: {e}")
-            return {"error": f"Error sending message: {e!s}"}
-
     def lark_get_message_resource(
         self,
         message_id: str,
@@ -573,7 +507,6 @@ def get_tools(self) -> List[FunctionTool]:
         return [
             FunctionTool(self.lark_list_chats),
             FunctionTool(self.lark_get_chat_messages),
-            FunctionTool(self.lark_send_message),
             FunctionTool(self.lark_get_message_resource),
             FunctionTool(self.lark_get_message_resource_key),
         ]

docs/conf.py

@@ -27,7 +27,7 @@
 project = 'CAMEL'
 copyright = '2024, CAMEL-AI.org'
 author = 'CAMEL-AI.org'
-release = '0.2.83a9'
+release = '0.2.83a7'
 
 html_favicon = (
     'https://raw.githubusercontent.com/camel-ai/camel/master/misc/favicon.png'

docs/mintlify/reference/camel.toolkits.lark_toolkit.mdx

@@ -157,37 +157,6 @@ member of the chat.
 - has_more: Whether there are more messages to fetch
 - page_token: Token to fetch the next page
 
-<a id="camel.toolkits.lark_toolkit.LarkToolkit.lark_send_message"></a>
-
-### lark_send_message
-
-```python
-def lark_send_message(
-    self,
-    receive_id: str,
-    text: str,
-    receive_id_type: Literal['open_id', 'user_id', 'union_id', 'email', 'chat_id'] = 'chat_id'
-):
-```
-
-Sends a message to a user or chat. If send message to
-a chat, use lark_list_chats to get chat_id first, if send
-message to a user, need user provide open_id, user_id,
-union_id or email.
-
-**Parameters:**
-
-- **receive_id** (str): The recipient identifier.
-- **text** (str): The text message content.
-- **receive_id_type** (str): The recipient ID type. Options: - "open_id" - "user_id" - "union_id" - "email" - "chat_id" (default)
-
-**Returns:**
-
-  Dict[str, object]: A dictionary containing:
-- message_id: The sent message ID
-- chat_id: The chat ID the message belongs to
-- msg_type: Message type (text)
-
 <a id="camel.toolkits.lark_toolkit.LarkToolkit.lark_get_message_resource"></a>
 
 ### lark_get_message_resource

examples/toolkits/lark_toolkit_example.py

@@ -64,17 +64,9 @@
 )
 print(f"Response: {response.msgs[0].content}\n")
 
-# Example 4: Send a message to chat
+# Example 4: Direct toolkit usage (without agent)
 print("=" * 60)
-print("Example 4: Send a message to chat")
-print("=" * 60)
-
-response = agent.step("Say hi to my first chat ")
-print(f"Response: {response.msgs[0].content}\n")
-
-# Example 5: Direct toolkit usage (without agent)
-print("=" * 60)
-print("Example 5: Direct toolkit usage")
+print("Example 4: Direct toolkit usage")
 print("=" * 60)
 
 # List chats directly