camel-ai 0.2.40__py3-none-any.whl → 0.2.42__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.40'
+__version__ = '0.2.42'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -327,7 +327,10 @@ class ChatAgent(BaseAgent):
         return False
 
     def update_memory(
-        self, message: BaseMessage, role: OpenAIBackendRole
+        self,
+        message: BaseMessage,
+        role: OpenAIBackendRole,
+        timestamp: Optional[float] = None,
     ) -> None:
         r"""Updates the agent memory with a new message.
 
@@ -335,12 +338,19 @@ class ChatAgent(BaseAgent):
             message (BaseMessage): The new message to add to the stored
                 messages.
             role (OpenAIBackendRole): The backend role type.
+            timestamp (Optional[float], optional): Custom timestamp for the
+                memory record. If None, current timestamp will be used.
+                (default: :obj:`None`)
         """
+        from datetime import timezone
+
         self.memory.write_record(
             MemoryRecord(
                 message=message,
                 role_at_backend=role,
-                timestamp=datetime.now().timestamp(),
+                timestamp=timestamp
+                if timestamp is not None
+                else datetime.now(timezone.utc).timestamp(),
                 agent_id=self.agent_id,
             )
         )
@@ -603,9 +613,6 @@ class ChatAgent(BaseAgent):
                 self._get_full_tool_schemas(),
             )
 
-            if self.single_iteration:
-                break
-
             if tool_call_requests := response.tool_call_requests:
                 # Process all tool calls
                 for tool_call_request in tool_call_requests:
@@ -625,6 +632,9 @@ class ChatAgent(BaseAgent):
                 if external_tool_call_requests:
                     break
 
+                if self.single_iteration:
+                    break
+
                 # If we're still here, continue the loop
                 continue
 
@@ -695,9 +705,6 @@ class ChatAgent(BaseAgent):
                 self._get_full_tool_schemas(),
             )
 
-            if self.single_iteration:
-                break
-
             if tool_call_requests := response.tool_call_requests:
                 # Process all tool calls
                 for tool_call_request in tool_call_requests:
@@ -718,6 +725,9 @@ class ChatAgent(BaseAgent):
                 if external_tool_call_requests:
                     break
 
+                if self.single_iteration:
+                    break
+
                 # If we're still here, continue the loop
                 continue
 
@@ -1331,8 +1341,18 @@ class ChatAgent(BaseAgent):
             tool_call_id=tool_call_id,
         )
 
-        self.update_memory(assist_msg, OpenAIBackendRole.ASSISTANT)
-        self.update_memory(func_msg, OpenAIBackendRole.FUNCTION)
+        # Use slightly different timestamps to ensure correct ordering
+        # This ensures the assistant message (tool call) always appears before
+        # the function message (tool result) in the conversation context
+        current_time = datetime.now().timestamp()
+        self.update_memory(
+            assist_msg, OpenAIBackendRole.ASSISTANT, timestamp=current_time
+        )
+        self.update_memory(
+            func_msg,
+            OpenAIBackendRole.FUNCTION,
+            timestamp=current_time + 0.001,
+        )
 
         # Record information about this tool call
         tool_record = ToolCallingRecord(

camel/datasets/few_shot_generator.py

@@ -201,19 +201,27 @@ class FewShotGenerator(BaseGenerator):
                     raise TypeError(f"Rationale {rationale} is not a string.")
 
                 try:
-                    verifier_response = await self.verifier.verify(
-                        solution=rationale,
-                        reference_answer=None,
+                    verifier_response = await asyncio.wait_for(
+                        self.verifier.verify(
+                            solution=rationale,
+                            reference_answer=None,
+                        ),
+                        timeout=180,
                     )
                     if not verifier_response or not verifier_response.result:
                         raise ValueError(
                             "Verifier unsuccessful, response: "
                             f"{verifier_response}"
                         )
-                except (ValueError, AttributeError) as e:
+                except (ValueError, AttributeError, asyncio.TimeoutError) as e:
+                    error_msg = (
+                        "Verifier timeout"
+                        if isinstance(e, asyncio.TimeoutError)
+                        else f"Verifier issue: {e}"
+                    )
                     logger.warning(
-                        f"Verifier issue: {e}, "
-                        f"retrying... ({retries + 1}/{max_retries})"
+                        f"{error_msg}, retrying... "
+                        f"({retries + 1}/{max_retries})"
                     )
                     retries += 1
                     continue

camel/environments/single_step.py

@@ -224,7 +224,7 @@ class SingleStepEnv:
             raise TypeError(f"Unsupported dataset type: {type(self.dataset)}")
 
     async def step(
-        self, action: Union[Action, List[Action], str]
+        self, action: Union[Action, List[Action], str, Dict[int, str]]
     ) -> Union[
         Tuple[Observation, float, bool, Dict[str, Any]],
         List[Tuple[Observation, float, bool, Dict[str, Any]]],
@@ -242,13 +242,15 @@ class SingleStepEnv:
         the observation will not change.
 
         Args:
-            action (Union[Action, List[Action], str]):
+            action (Union[Action, List[Action], str, Dict[int, str]]):
                 The action(s) taken by the agent,
                     which should contain the response(s)
                 to the observation(s). Can be:
                 - A single `Action` object (for batch size 1),
                 - A list of `Action` objects (for batched evaluation),
                 - A raw string (only allowed when batch size is 1).
+                - A dict that maps indices to their `llm_response`
+                    (for batched evaluation)
 
         Returns:
             Union[Tuple[Observation, float, bool, Dict[str, Any]], List[...]]:
@@ -293,6 +295,7 @@ class SingleStepEnv:
                 f"total batch size ({self.current_batch_size})"
             )
 
+        indices = [act.index for act in actions]
         proposed_solutions = [act.llm_response for act in actions]
         ground_truths: List[str] = []
         for idx in indices:
@@ -334,21 +337,22 @@ class SingleStepEnv:
             ).as_tuple()
             for i in range(len(actions))
         ]
+
         for _, idx in enumerate(indices):
             self._states_done[idx] = True
 
         return step_results[0] if len(step_results) == 1 else step_results
 
     def _normalize_actions(
-        self, action: Union[Action, List[Action], str]
+        self, action: Union[Action, List[Action], str, Dict[int, str]]
     ) -> List[Action]:
         r"""Normalize the user-provided action(s) into a validated list
         of `Action` objects.
 
         This method handles flexibility in input format by converting
-        raw strings (only allowed when batch size is 1) and ensuring
-        all necessary structure and integrity checks on actions
-        (e.g., index bounds, duplicates).
+        raw strings (only allowed when batch size is 1) and dictionaries,
+        ensuring all necessary structure and integrity checks on
+        actions (e.g., index bounds, duplicates).
 
         Args:
             action (Union[Action, List[Action], str]):
@@ -357,6 +361,7 @@ class SingleStepEnv:
                 - A list of `Action` objects.
                 - A raw string (if `batch_size == 1`), auto-wrapped
                     in an `Action`.
+                - A dict mapping int indices to str responses
 
         Returns:
             List[Action]: A list of validated `Action` instances
@@ -368,8 +373,9 @@ class SingleStepEnv:
                 - Action list is empty,
                 - Index mismatches expected values
                     (e.g., 0 for batch size 1),
-                - Wrong structure is used
-                    (e.g., string used with batch size > 1).
+                - Wrong structure is used (e.g.,
+                    string used with batch size > 1,
+                    dict used with batch size == 1).
             TypeError: If the action is of an unsupported type.
         """
 
@@ -380,9 +386,20 @@ class SingleStepEnv:
                     " when batch_size == 1"
                 )
             logger.warning("Auto-converting from str to Action", stacklevel=2)
-            action = Action(index=0, llm_response=action)
+            actions = [Action(index=0, llm_response=action)]
+
+        elif isinstance(action, dict):
+            if not all(isinstance(k, int) for k in action.keys()):
+                raise ValueError("All dictionary keys must be integers")
 
-        if isinstance(action, Action):
+            if self.current_batch_size == 1 and list(action.keys()) != [0]:
+                raise ValueError(
+                    "For batch_size=1, dict input must have exactly one key: 0"
+                )
+            actions = [
+                Action(index=k, llm_response=v) for k, v in action.items()
+            ]
+        elif isinstance(action, Action):
             actions = [action]
         elif isinstance(action, list):
             if not action:
@@ -397,7 +414,7 @@ class SingleStepEnv:
 
         if self.current_batch_size == 1 and len(actions) != 1:
             raise ValueError(
-                "For batch_size=1, expect a single Action or a "
+                "For batch_size=1, expect a single Action, a dictionary or a "
                 "list containing exactly one Action"
             )
 

camel/memories/blocks/chat_history_block.py

@@ -74,9 +74,52 @@ class ChatHistoryBlock(MemoryBlock):
             return list()
 
         chat_records: List[MemoryRecord] = []
-        truncate_idx = -window_size if window_size is not None else 0
-        for record_dict in record_dicts[truncate_idx:]:
-            chat_records.append(MemoryRecord.from_dict(record_dict))
+        if window_size is not None and window_size >= 0:
+            # Initial preserved index: Keep first message
+            # if it's SYSTEM/DEVELOPER (index 0)
+            start_index = (
+                1
+                if (
+                    record_dicts
+                    and record_dicts[0]['role_at_backend']
+                    in {OpenAIBackendRole.SYSTEM, OpenAIBackendRole.DEVELOPER}
+                )
+                else 0
+            )
+
+            """
+            Message Processing Logic:
+            1. Preserve first system/developer message (if needed)
+            2. Keep latest window_size messages from the rest
+            
+            Examples:
+            - Case 1: First message is SYSTEM, total 5 messages, window_size=2
+            Input: [system_msg, user_msg1, user_msg2, user_msg3, user_msg4]
+            Result: [system_msg] + [user_msg3, user_msg4]
+
+            - Case 2: First message is USER, total 5 messages, window_size=3
+            Input: [user_msg1, user_msg2, user_msg3, user_msg4, , user_msg5]
+            Result: [user_msg3, user_msg4, , user_msg5]
+            """
+            preserved_messages = record_dicts[
+                :start_index
+            ]  # Preserve system message (if exists)
+            sliding_messages = record_dicts[
+                start_index:
+            ]  # Messages to be truncated
+
+            # Take last window_size messages (if exceeds limit)
+            truncated_messages = sliding_messages[-window_size:]
+
+            # Combine preserved messages with truncated window messages
+            final_records = preserved_messages + truncated_messages
+        else:
+            # Return full records when no window restriction
+            final_records = record_dicts
+
+        chat_records = [
+            MemoryRecord.from_dict(record) for record in final_records
+        ]
 
         # We assume that, in the chat history memory, the closer the record is
         # to the current message, the more score it will be.

camel/models/vllm_model.py

@@ -162,6 +162,14 @@ class VLLMModel(BaseModelBackend):
         if response_format:
             kwargs["response_format"] = {"type": "json_object"}
 
+        # Remove additionalProperties from each tool's function parameters
+        if tools and "tools" in kwargs:
+            for tool in kwargs["tools"]:
+                if "function" in tool and "parameters" in tool["function"]:
+                    tool["function"]["parameters"].pop(
+                        "additionalProperties", None
+                    )
+
         response = await self._async_client.chat.completions.create(
             messages=messages,
             model=self.model_type,
@@ -197,6 +205,14 @@ class VLLMModel(BaseModelBackend):
         if response_format:
             kwargs["response_format"] = {"type": "json_object"}
 
+        # Remove additionalProperties from each tool's function parameters
+        if tools and "tools" in kwargs:
+            for tool in kwargs["tools"]:
+                if "function" in tool and "parameters" in tool["function"]:
+                    tool["function"]["parameters"].pop(
+                        "additionalProperties", None
+                    )
+
         response = self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,