Merge branch 'master' into st_fix_deepseek_stream

Author: Wendong-Fan

camel/agents/chat_agent.py

@@ -506,9 +506,7 @@ def __init__(
 
         # Set up system message and initialize messages
         self._original_system_message = (
-            BaseMessage.make_assistant_message(
-                role_name="Assistant", content=system_message
-            )
+            BaseMessage.make_system_message(system_message)
             if isinstance(system_message, str)
             else system_message
         )
@@ -1644,10 +1642,7 @@ def _generate_system_message_for_output_language(
             content = self._original_system_message.content + language_prompt
             return self._original_system_message.create_new_instance(content)
         else:
-            return BaseMessage.make_assistant_message(
-                role_name="Assistant",
-                content=language_prompt,
-            )
+            return BaseMessage.make_system_message(language_prompt)
 
     def init_messages(self) -> None:
         r"""Initializes the stored messages list with the current system
@@ -1665,6 +1660,62 @@ def init_messages(self) -> None:
                 )
             )
 
+    def update_system_message(
+        self,
+        system_message: Union[BaseMessage, str],
+        reset_memory: bool = True,
+    ) -> None:
+        r"""Update the system message.
+        It will reset conversation with new system message.
+
+        Args:
+            system_message (Union[BaseMessage, str]): The new system message.
+                Can be either a BaseMessage object or a string.
+                If a string is provided, it will be converted
+                into a BaseMessage object.
+            reset_memory (bool):
+                Whether to reinitialize conversation messages after updating
+                the system message. Defaults to True.
+        """
+        if system_message is None:
+            raise ValueError("system_message is required and cannot be None. ")
+        self._original_system_message = (
+            BaseMessage.make_system_message(system_message)
+            if isinstance(system_message, str)
+            else system_message
+        )
+        self._system_message = (
+            self._generate_system_message_for_output_language()
+        )
+        if reset_memory:
+            self.init_messages()
+
+    def append_to_system_message(
+        self, content: str, reset_memory: bool = True
+    ) -> None:
+        """Append additional context to existing system message.
+
+        Args:
+            content (str): The additional system message.
+            reset_memory (bool):
+                Whether to reinitialize conversation messages after appending
+                additional context. Defaults to True.
+        """
+        original_content = (
+            self._original_system_message.content
+            if self._original_system_message
+            else ""
+        )
+        new_system_message = original_content + '\n' + content
+        self._original_system_message = BaseMessage.make_system_message(
+            new_system_message
+        )
+        self._system_message = (
+            self._generate_system_message_for_output_language()
+        )
+        if reset_memory:
+            self.init_messages()
+
     def reset_to_original_system_message(self) -> None:
         r"""Reset system message to original, removing any appended context.
 
@@ -4541,23 +4592,29 @@ def _clone_tools(
                         # Toolkit doesn't support cloning, use original
                         cloned_toolkits[toolkit_id] = toolkit_instance
 
-                if getattr(
-                    tool.func, "__message_integration_enhanced__", False
-                ):
-                    cloned_tools.append(
-                        FunctionTool(
-                            func=tool.func,
-                            openai_tool_schema=tool.get_openai_tool_schema(),
-                        )
-                    )
-                    continue
-
                 # Get the method from the cloned (or original) toolkit
                 toolkit = cloned_toolkits[toolkit_id]
                 method_name = tool.func.__name__
 
+                # Check if toolkit was actually cloned or just reused
+                toolkit_was_cloned = toolkit is not toolkit_instance
+
                 if hasattr(toolkit, method_name):
                     new_method = getattr(toolkit, method_name)
+
+                    # If toolkit wasn't cloned (stateless), preserve the
+                    # original function to maintain any enhancements/wrappers
+                    if not toolkit_was_cloned:
+                        # Toolkit is stateless, safe to reuse original function
+                        cloned_tools.append(
+                            FunctionTool(
+                                func=tool.func,
+                                openai_tool_schema=tool.get_openai_tool_schema(),
+                            )
+                        )
+                        continue
+
+                    # Toolkit was cloned, use the new method
                     # Wrap cloned method into a new FunctionTool,
                     # preserving schema
                     try:

camel/messages/base.py

@@ -178,6 +178,32 @@ def make_assistant_message(
             OpenAIVisionDetailType(video_detail).value,
         )
 
+    @classmethod
+    def make_system_message(
+        cls,
+        content: str,
+        role_name: str = "System",
+        meta_dict: Optional[Dict[str, str]] = None,
+    ) -> "BaseMessage":
+        r"""Create a new system message.
+
+        Args:
+            content (str): The content of the system message.
+            role_name (str): The name of the system role.
+                (default: :obj:`"System"`)
+            meta_dict (Optional[Dict[str, str]]): Additional metadata
+                dictionary for the message.
+
+        Returns:
+            BaseMessage: The new system message.
+        """
+        return cls(
+            role_name,
+            RoleType.SYSTEM,
+            meta_dict,
+            content,
+        )
+
     def create_new_instance(self, content: str) -> "BaseMessage":
         r"""Create a new instance of the :obj:`BaseMessage` with updated
         content.

camel/toolkits/message_integration.py

@@ -148,12 +148,10 @@ def get_message_tool(self) -> FunctionTool:
         """
         return FunctionTool(self.send_message_to_user)
 
-    def register_toolkits(
-        self, toolkit: BaseToolkit, tool_names: Optional[List[str]] = None
-    ) -> BaseToolkit:
-        r"""Add messaging capabilities to toolkit methods.
+    def register_toolkits(self, toolkit: BaseToolkit) -> BaseToolkit:
+        r"""Add messaging capabilities to all toolkit methods.
 
-        This method modifies a toolkit so that specified tools can send
+        This method modifies a toolkit so that all its tools can send
         status messages to users while executing their primary function.
         The tools will accept optional messaging parameters:
         - message_title: Title of the status message
@@ -162,20 +160,18 @@ def register_toolkits(
 
         Args:
             toolkit: The toolkit to add messaging capabilities to
-            tool_names: List of specific tool names to modify.
-                       If None, messaging is added to all tools.
 
         Returns:
-            The toolkit with messaging capabilities added
+            The same toolkit instance with messaging capabilities added to
+                all methods.
         """
         original_tools = toolkit.get_tools()
         enhanced_methods = {}
         for tool in original_tools:
             method_name = tool.func.__name__
-            if tool_names is None or method_name in tool_names:
-                enhanced_func = self._add_messaging_to_tool(tool.func)
-                enhanced_methods[method_name] = enhanced_func
-                setattr(toolkit, method_name, enhanced_func)
+            enhanced_func = self._add_messaging_to_tool(tool.func)
+            enhanced_methods[method_name] = enhanced_func
+            setattr(toolkit, method_name, enhanced_func)
         original_get_tools_method = toolkit.get_tools
 
         def enhanced_get_tools() -> List[FunctionTool]:
@@ -201,7 +197,7 @@ def enhanced_get_tools() -> List[FunctionTool]:
             def enhanced_clone_for_new_session(new_session_id=None):
                 cloned_toolkit = original_clone_method(new_session_id)
                 return message_integration_instance.register_toolkits(
-                    cloned_toolkit, tool_names
+                    cloned_toolkit
                 )
 
             toolkit.clone_for_new_session = enhanced_clone_for_new_session
@@ -300,6 +296,12 @@ def _add_messaging_to_tool(self, func: Callable) -> Callable:
         This internal method modifies the function signature and docstring
         to include optional messaging parameters that trigger status updates.
         """
+        if getattr(func, "__message_integration_enhanced__", False):
+            logger.debug(
+                f"Function {func.__name__} already enhanced, skipping"
+            )
+            return func
+
         # Get the original signature
         original_sig = inspect.signature(func)