camel-ai 0.2.73a2__py3-none-any.whl → 0.2.73a3__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.73a2'
+__version__ = '0.2.73a3'
 
 __all__ = [
     '__version__',

camel/toolkits/excel_toolkit.py

@@ -14,6 +14,7 @@
 
 # Enables postponed evaluation of annotations (for string-based type hints)
 import os
+from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional, Union
 
 from camel.logger import get_logger
@@ -41,7 +42,7 @@ class ExcelToolkit(BaseToolkit):
     def __init__(
         self,
         timeout: Optional[float] = None,
-        file_path: Optional[str] = None,
+        working_directory: Optional[str] = None,
     ):
         r"""Initializes a new instance of the ExcelToolkit class.
 
@@ -49,16 +50,28 @@ class ExcelToolkit(BaseToolkit):
             timeout (Optional[float]): The timeout value for API requests
                 in seconds. If None, no timeout is applied.
                 (default: :obj:`None`)
-            file_path (Optional[str]): Path to an existing Excel file to load.
-                (default: :obj:`None`)
+            working_directory (str, optional): The default directory for
+                output files. If not provided, it will be determined by the
+                `CAMEL_WORKDIR` environment variable (if set). If the
+                environment variable is not set, it defaults to
+                `camel_working_dir`.
         """
         super().__init__(timeout=timeout)
-        self.file_path = file_path
         self.wb = None
-        if file_path and os.path.exists(file_path):
-            from openpyxl import load_workbook
+        if working_directory:
+            self.working_directory = Path(working_directory).resolve()
+        else:
+            camel_workdir = os.environ.get("CAMEL_WORKDIR")
+            if camel_workdir:
+                self.working_directory = Path(camel_workdir).resolve()
+            else:
+                self.working_directory = Path("./camel_working_dir").resolve()
 
-            self.wb = load_workbook(file_path)
+        self.working_directory.mkdir(parents=True, exist_ok=True)
+        logger.info(
+            f"ExcelToolkit initialized with output directory: "
+            f"{self.working_directory}"
+        )
 
     def _validate_file_path(self, file_path: str) -> bool:
         r"""Validate file path for security.
@@ -232,12 +245,11 @@ class ExcelToolkit(BaseToolkit):
             logger.error(f"Failed to process Excel file {document_path}: {e}")
             return f"Failed to process Excel file {document_path}: {e}"
 
-    def _save_workbook(self, file_path: Optional[str] = None) -> str:
+    def _save_workbook(self, file_path: str) -> str:
         r"""Save the current workbook to file.
 
         Args:
-            file_path (Optional[str]): The path to save the workbook.
-                If None, uses self.file_path.
+            file_path (str): The path to save the workbook.
 
         Returns:
             str: Success or error message.
@@ -245,23 +257,46 @@ class ExcelToolkit(BaseToolkit):
         if not self.wb:
             return "Error: No workbook loaded to save."
 
-        save_path = file_path or self.file_path
-        if not save_path:
-            return "Error: No file path specified for saving."
-
-        if not self._validate_file_path(save_path):
+        if not self._validate_file_path(file_path):
             return "Error: Invalid file path for saving."
 
         try:
-            self.wb.save(save_path)
-            return f"Workbook saved successfully to {save_path}"
+            self.wb.save(file_path)
+            return f"Workbook saved successfully to {file_path}"
         except Exception as e:
             logger.error(f"Failed to save workbook: {e}")
             return f"Error: Failed to save workbook: {e}"
 
+    def save_workbook(self, filename: str) -> str:
+        r"""Save the current in-memory workbook to a file.
+
+        Args:
+            filename (str): The filename to save the workbook. Must end with
+                .xlsx extension. The file will be saved in self.
+                working_directory.
+
+        Returns:
+            str: Success message or error details.
+        """
+        if not self.wb:
+            return "Error: No workbook is currently loaded in memory."
+
+        # Validate filename
+        if not filename:
+            return "Error: Filename is required."
+
+        if not filename.endswith('.xlsx'):
+            return "Error: Filename must end with .xlsx extension."
+
+        # Create full path in working directory
+        file_path = self.working_directory / filename
+        resolved_file_path = str(file_path.resolve())
+
+        return self._save_workbook(resolved_file_path)
+
     def create_workbook(
         self,
-        file_path: str,
+        filename: Optional[str] = None,
         sheet_name: Optional[str] = None,
         data: Optional[List[List[Union[str, int, float, None]]]] = None,
     ) -> str:
@@ -271,8 +306,9 @@ class ExcelToolkit(BaseToolkit):
         toolkit to work with the new file and optionally adds initial data.
 
         Args:
-            file_path (str): Where to save the new Excel file. Must end with .
-                xlsx.
+            filename (Optional[str]): The filename for the workbook. Must end
+                with .xlsx extension. The file will be saved in
+                self.working_directory. (default: :obj:`None`)
             sheet_name (Optional[str]): Name for the first sheet. If None,
                 creates "Sheet1". (default: :obj:`None`)
             data (Optional[List[List[Union[str, int, float, None]]]]): Initial
@@ -284,14 +320,31 @@ class ExcelToolkit(BaseToolkit):
         """
         from openpyxl import Workbook
 
-        if not self._validate_file_path(file_path):
+        # Validate filename
+        if filename is None:
+            return "Error: Filename is required."
+
+        if not filename.endswith('.xlsx'):
+            return "Error: Filename must end with .xlsx extension."
+
+        # Create full path in working directory
+        file_path = self.working_directory / filename
+        resolved_file_path = str(file_path.resolve())
+
+        if not self._validate_file_path(resolved_file_path):
             return "Error: Invalid file path."
 
+        # Check if file already exists
+        if os.path.exists(resolved_file_path):
+            return (
+                f"Error: File {filename} already exists in "
+                f"{self.working_directory}."
+            )
+
         try:
             # Create a new workbook
             wb = Workbook()
             self.wb = wb
-            self.file_path = file_path
 
             # Handle sheet creation safely
             if sheet_name:
@@ -312,42 +365,55 @@ class ExcelToolkit(BaseToolkit):
                     ws.append(row)
 
             # Save the workbook to the specified file path
-            wb.save(file_path)
+            wb.save(resolved_file_path)
 
-            return f"Workbook created successfully at {file_path}"
+            return f"Workbook created successfully at {resolved_file_path}"
         except Exception as e:
             logger.error(f"Failed to create workbook: {e}")
             return f"Error: Failed to create workbook: {e}"
 
-    def delete_workbook(self, file_path: Optional[str] = None) -> str:
-        r"""Delete a spreadsheet file.
+    def delete_workbook(self, filename: str) -> str:
+        r"""Delete a spreadsheet file from the working directory.
 
         Args:
-            file_path (Optional[str]): The path of the file to delete.
-                If None, uses self.file_path.
+            filename (str): The filename to delete. Must end with .xlsx
+                extension. The file will be deleted from self.
+                working_directory.
 
         Returns:
-            str: Success message.
+            str: Success message or error details.
         """
-        target_path = file_path or self.file_path
-        if not target_path:
-            return "Error: No file path specified for deletion."
+        # Validate filename
+        if not filename:
+            return "Error: Filename is required."
+
+        if not filename.endswith('.xlsx'):
+            return "Error: Filename must end with .xlsx extension."
+
+        # Create full path in working directory
+        file_path = self.working_directory / filename
+        target_path = str(file_path.resolve())
 
         if not self._validate_file_path(target_path):
             return "Error: Invalid file path."
 
         if not os.path.exists(target_path):
-            return f"File {target_path} does not exist."
+            return (
+                f"Error: File {filename} does not exist in "
+                f"{self.working_directory}."
+            )
 
         try:
             os.remove(target_path)
-            if target_path == self.file_path:
-                self.wb = None
-                self.file_path = None
-            return f"Workbook {target_path} deleted successfully."
+            # Clean up workbook if one is loaded
+            self.wb = None
+            return (
+                f"Workbook {filename} deleted successfully from "
+                f"{self.working_directory}."
+            )
         except Exception as e:
             logger.error(f"Failed to delete workbook: {e}")
-            return f"Failed to delete workbook {target_path}: {e}"
+            return f"Error: Failed to delete workbook {filename}: {e}"
 
     def create_sheet(
         self,
@@ -379,9 +445,6 @@ class ExcelToolkit(BaseToolkit):
                 for row in data:
                     ws.append(row)
 
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return f"Sheet {sheet_name} created successfully."
         except Exception as e:
             logger.error(f"Failed to create sheet: {e}")
@@ -408,9 +471,6 @@ class ExcelToolkit(BaseToolkit):
         try:
             ws = self.wb[sheet_name]
             self.wb.remove(ws)
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return f"Sheet {sheet_name} deleted successfully."
         except Exception as e:
             logger.error(f"Failed to delete sheet: {e}")
@@ -439,9 +499,6 @@ class ExcelToolkit(BaseToolkit):
                 for cell in row:
                     cell.value = None
 
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return f"Sheet {sheet_name} cleared successfully."
         except Exception as e:
             logger.error(f"Failed to clear sheet: {e}")
@@ -479,7 +536,6 @@ class ExcelToolkit(BaseToolkit):
         num_rows = end_row - start_row + 1
         ws.delete_rows(start_row, num_rows)
 
-        self._save_workbook()
         return (
             f"Deleted rows {start_row} to {end_row} from sheet "
             f"{sheet_name} successfully."
@@ -518,7 +574,6 @@ class ExcelToolkit(BaseToolkit):
         num_cols = end_col - start_col + 1
         ws.delete_cols(start_col, num_cols)
 
-        self._save_workbook()
         return (
             f"Deleted columns {start_col} to {end_col} from sheet "
             f"{sheet_name} successfully."
@@ -585,9 +640,6 @@ class ExcelToolkit(BaseToolkit):
                 ws[cell_reference].value = None
             else:
                 ws[cell_reference] = value
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return (
                 f"Cell {cell_reference} updated successfully in sheet "
                 f"{sheet_name}."
@@ -765,10 +817,9 @@ class ExcelToolkit(BaseToolkit):
                     if col_idx < len(values[row_idx]):
                         cell.value = values[row_idx][col_idx]
 
-        self._save_workbook()
         return f"Values set for range {cell_range} in sheet {sheet_name}."
 
-    def export_sheet_to_csv(self, sheet_name: str, csv_path: str) -> str:
+    def export_sheet_to_csv(self, sheet_name: str, csv_filename: str) -> str:
         r"""Export a specific sheet to CSV format.
 
         Use this to convert Excel sheets to CSV files for compatibility or
@@ -776,24 +827,63 @@ class ExcelToolkit(BaseToolkit):
 
         Args:
             sheet_name (str): Name of the sheet to export.
-            csv_path (str): File path where CSV will be saved.
+            csv_filename (str): Filename for the CSV file. Must end with .csv
+                extension. The file will be saved in self.working_directory.
 
         Returns:
             str: Success confirmation message or error details.
         """
         if not self.wb:
-            return "Error: Workbook not initialized."
+            return (
+                "Error: No workbook is currently loaded. Use "
+                "extract_excel_content to load a workbook first."
+            )
 
         if sheet_name not in self.wb.sheetnames:
-            return f"Error: Sheet {sheet_name} does not exist."
+            return (
+                f"Error: Sheet {sheet_name} does not exist in the current "
+                "workbook."
+            )
 
-        import pandas as pd
+        # Validate filename
+        if not csv_filename:
+            return "Error: CSV filename is required."
 
-        # Read the specific sheet
-        df = pd.read_excel(self.file_path, sheet_name=sheet_name)
-        df.to_csv(csv_path, index=False)
+        if not csv_filename.endswith('.csv'):
+            return "Error: CSV filename must end with .csv extension."
 
-        return f"Sheet {sheet_name} exported to CSV: {csv_path}"
+        # Create full path in working directory
+        csv_path = self.working_directory / csv_filename
+        resolved_csv_path = str(csv_path.resolve())
+
+        if not self._validate_file_path(resolved_csv_path):
+            return "Error: Invalid file path."
+
+        try:
+            # Get the worksheet
+            ws = self.wb[sheet_name]
+
+            # Convert worksheet to list of lists
+            data = []
+            for row in ws.iter_rows(values_only=True):
+                data.append(list(row))
+
+            # Write to CSV
+            import csv
+
+            with open(
+                resolved_csv_path, 'w', newline='', encoding='utf-8'
+            ) as csvfile:
+                writer = csv.writer(csvfile)
+                writer.writerows(data)
+
+            return (
+                f"Sheet {sheet_name} exported to {csv_filename} "
+                f"in {self.working_directory}."
+            )
+        except Exception as e:
+            logger.error(f"Failed to export sheet to CSV: {e}")
+            return f"Error: Failed to export sheet {sheet_name} to CSV: {e}"
 
     def get_rows(
         self,
@@ -862,7 +952,6 @@ class ExcelToolkit(BaseToolkit):
             return f"Error: Sheet {sheet_name} does not exist."
         ws = self.wb[sheet_name]
         ws.append(row_data)
-        self._save_workbook()
         return f"Row appended to sheet {sheet_name} successfully."
 
     def update_row(
@@ -901,7 +990,6 @@ class ExcelToolkit(BaseToolkit):
         for col_idx, value in enumerate(row_data, 1):
             ws.cell(row=row_number, column=col_idx).value = value
 
-        self._save_workbook()
         return f"Row {row_number} updated in sheet {sheet_name} successfully."
 
     def get_tools(self) -> List[FunctionTool]:
@@ -916,6 +1004,7 @@ class ExcelToolkit(BaseToolkit):
             # File operations
             FunctionTool(self.extract_excel_content),
             FunctionTool(self.create_workbook),
+            FunctionTool(self.save_workbook),
             FunctionTool(self.delete_workbook),
             FunctionTool(self.export_sheet_to_csv),
             # Sheet operations

camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py

@@ -110,6 +110,11 @@ class WebSocketBrowserWrapper:
         self.process: Optional[subprocess.Popen] = None
         self.websocket = None
         self.server_port = None
+        self._send_lock = asyncio.Lock()  # Lock for sending messages
+        self._receive_task = None  # Background task for receiving messages
+        self._pending_responses: Dict[
+            str, asyncio.Future[Dict[str, Any]]
+        ] = {}  # Message ID -> Future
 
         # Logging configuration
         self.browser_log_to_file = (config or {}).get(
@@ -251,11 +256,22 @@ class WebSocketBrowserWrapper:
                 f"Failed to connect to WebSocket server: {e}"
             ) from e
 
+        # Start the background receiver task
+        self._receive_task = asyncio.create_task(self._receive_loop())
+
         # Initialize the browser toolkit
         await self._send_command('init', self.config)
 
     async def stop(self):
         """Stop the WebSocket connection and server."""
+        # Cancel the receiver task
+        if self._receive_task and not self._receive_task.done():
+            self._receive_task.cancel()
+            try:
+                await self._receive_task
+            except asyncio.CancelledError:
+                pass
+
         if self.websocket:
             try:
                 await self._send_command('shutdown', {})
@@ -327,6 +343,39 @@ class WebSocketBrowserWrapper:
         except Exception as e:
             logger.error(f"Failed to write to log file: {e}")
 
+    async def _receive_loop(self):
+        r"""Background task to receive messages from WebSocket."""
+        try:
+            while self.websocket:
+                try:
+                    response_data = await self.websocket.recv()
+                    response = json.loads(response_data)
+
+                    message_id = response.get('id')
+                    if message_id and message_id in self._pending_responses:
+                        # Set the result for the waiting coroutine
+                        future = self._pending_responses.pop(message_id)
+                        if not future.done():
+                            future.set_result(response)
+                    else:
+                        # Log unexpected messages
+                        logger.warning(
+                            f"Received unexpected message: {response}"
+                        )
+
+                except asyncio.CancelledError:
+                    break
+                except Exception as e:
+                    logger.error(f"Error in receive loop: {e}")
+                    # Notify all pending futures of the error
+                    for future in self._pending_responses.values():
+                        if not future.done():
+                            future.set_exception(e)
+                    self._pending_responses.clear()
+                    break
+        finally:
+            logger.debug("Receive loop terminated")
+
     async def _ensure_connection(self) -> None:
         """Ensure WebSocket connection is alive."""
         if not self.websocket:
@@ -350,39 +399,39 @@ class WebSocketBrowserWrapper:
         message_id = str(uuid.uuid4())
         message = {'id': message_id, 'command': command, 'params': params}
 
-        try:
-            # Send command
-            if self.websocket is None:
-                raise RuntimeError("WebSocket connection not established")
-            await self.websocket.send(json.dumps(message))
+        # Create a future for this message
+        future: asyncio.Future[Dict[str, Any]] = asyncio.Future()
+        self._pending_responses[message_id] = future
 
-            # Wait for response with matching ID
-            while True:
-                try:
-                    if self.websocket is None:
-                        raise RuntimeError("WebSocket connection lost")
-                    response_data = await asyncio.wait_for(
-                        self.websocket.recv(), timeout=60.0
-                    )
-                    response = json.loads(response_data)
-
-                    # Check if this is the response we're waiting for
-                    if response.get('id') == message_id:
-                        if not response.get('success'):
-                            raise RuntimeError(
-                                f"Command failed: {response.get('error')}"
-                            )
-                        return response['result']
+        try:
+            # Use lock only for sending to prevent interleaved messages
+            async with self._send_lock:
+                if self.websocket is None:
+                    raise RuntimeError("WebSocket connection not established")
+                await self.websocket.send(json.dumps(message))
+
+            # Wait for response (no lock needed, handled by background
+            # receiver)
+            try:
+                response = await asyncio.wait_for(future, timeout=60.0)
 
-                except asyncio.TimeoutError:
+                if not response.get('success'):
                     raise RuntimeError(
-                        f"Timeout waiting for response to command: {command}"
+                        f"Command failed: {response.get('error')}"
                     )
-                except json.JSONDecodeError as e:
-                    logger.warning(f"Failed to decode WebSocket response: {e}")
-                    continue
+                return response['result']
+
+            except asyncio.TimeoutError:
+                # Remove from pending if timeout
+                self._pending_responses.pop(message_id, None)
+                raise RuntimeError(
+                    f"Timeout waiting for response to command: {command}"
+                )
 
         except Exception as e:
+            # Clean up the pending response
+            self._pending_responses.pop(message_id, None)
+
             # Check if it's a connection closed error
             if (
                 "close frame" in str(e)

camel/toolkits/message_integration.py

@@ -36,7 +36,7 @@ class ToolkitMessageIntegration:
         >>> # Using default message handler with toolkit
         >>> message_integration = ToolkitMessageIntegration()
         >>> search_with_messaging = message_integration.
-        add_messaging_to_toolkit(
+        register_toolkits(
         ...     SearchToolkit()
         ... )
 
@@ -44,7 +44,7 @@ class ToolkitMessageIntegration:
         >>> def search_web(query: str) -> list:
         ...     return ["result1", "result2"]
         ...
-        >>> enhanced_tools = message_integration.add_messaging_to_functions
+        >>> enhanced_tools = message_integration.register_functions
         ([search_web])
 
         >>> # Using custom message handler with different parameters
@@ -148,7 +148,7 @@ class ToolkitMessageIntegration:
         """
         return FunctionTool(self.send_message_to_user)
 
-    def add_messaging_to_toolkit(
+    def register_toolkits(
         self, toolkit: BaseToolkit, tool_names: Optional[List[str]] = None
     ) -> BaseToolkit:
         r"""Add messaging capabilities to toolkit methods.
@@ -168,26 +168,72 @@ class ToolkitMessageIntegration:
         Returns:
             The toolkit with messaging capabilities added
         """
-        original_get_tools = toolkit.get_tools
+        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)
+        original_get_tools_method = toolkit.get_tools
 
         def enhanced_get_tools() -> List[FunctionTool]:
-            tools = original_get_tools()
-            enhanced_tools = []
+            tools = []
+            for _, enhanced_method in enhanced_methods.items():
+                tools.append(FunctionTool(enhanced_method))
+            original_tools_list = original_get_tools_method()
+            for tool in original_tools_list:
+                if tool.func.__name__ not in enhanced_methods:
+                    tools.append(tool)
 
-            for tool in tools:
-                if tool_names is None or tool.func.__name__ in tool_names:
-                    enhanced_func = self._add_messaging_to_tool(tool.func)
-                    enhanced_tools.append(FunctionTool(enhanced_func))
-                else:
-                    enhanced_tools.append(tool)
-
-            return enhanced_tools
+            return tools
 
-        # Replace the get_tools method
         toolkit.get_tools = enhanced_get_tools  # type: ignore[method-assign]
+
+        # Also handle clone_for_new_session
+        # if it exists to ensure cloned toolkits
+        # also have message integration
+        if hasattr(toolkit, 'clone_for_new_session'):
+            original_clone_method = toolkit.clone_for_new_session
+            message_integration_instance = self
+
+            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
+                )
+
+            toolkit.clone_for_new_session = enhanced_clone_for_new_session
+
         return toolkit
 
-    def add_messaging_to_functions(
+    def _create_bound_method_wrapper(
+        self, enhanced_func: Callable, toolkit_instance
+    ) -> Callable:
+        r"""Create a wrapper that mimics a bound method for _clone_tools.
+
+        This wrapper preserves the toolkit instance reference while maintaining
+        the enhanced messaging functionality.
+        """
+
+        # Create a wrapper that appears as a bound method to _clone_tools
+        @wraps(enhanced_func)
+        def bound_method_wrapper(*args, **kwargs):
+            return enhanced_func(*args, **kwargs)
+
+        # Make it appear as a bound method by setting __self__
+        bound_method_wrapper.__self__ = toolkit_instance  # type: ignore[attr-defined]
+
+        # Preserve other important attributes
+        if hasattr(enhanced_func, '__signature__'):
+            bound_method_wrapper.__signature__ = enhanced_func.__signature__  # type: ignore[attr-defined]
+        if hasattr(enhanced_func, '__doc__'):
+            bound_method_wrapper.__doc__ = enhanced_func.__doc__
+
+        return bound_method_wrapper
+
+    def register_functions(
         self,
         functions: Union[List[FunctionTool], List[Callable]],
         function_names: Optional[List[str]] = None,
@@ -210,12 +256,12 @@ class ToolkitMessageIntegration:
         Example:
             >>> # With FunctionTools
             >>> tools = [FunctionTool(search_func), FunctionTool(analyze_func)]
-            >>> enhanced_tools = message_integration.add_messaging_to_functions
+            >>> enhanced_tools = message_integration.register_functions
             (tools)
 
             >>> # With callable functions
             >>> funcs = [search_web, analyze_data, generate_report]
-            >>> enhanced_tools = message_integration.add_messaging_to_functions
+            >>> enhanced_tools = message_integration.register_functions
             (
             ...     funcs,
             ...     function_names=['search_web', 'analyze_data']
@@ -257,6 +303,9 @@ class ToolkitMessageIntegration:
         # Get the original signature
         original_sig = inspect.signature(func)
 
+        # Check if the function is async
+        is_async = inspect.iscoroutinefunction(func)
+
         # Create new parameters for the enhanced function
         new_params = list(original_sig.parameters.values())
 
@@ -321,45 +370,123 @@ class ToolkitMessageIntegration:
         # Create the new signature
         new_sig = original_sig.replace(parameters=new_params)
 
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # Extract parameters using the callback
-            try:
-                params = self.extract_params_callback(kwargs)
-            except KeyError:
-                # If parameters are missing, just execute the original function
-                return func(*args, **kwargs)
-
-            # Check if we should send a message
-            should_send = False
-            if self.use_custom_handler:
-                should_send = any(p is not None and p != '' for p in params)
-            else:
-                # For default handler, params = (title, description,
-                # attachment)
-                should_send = bool(params[0]) or bool(params[1])
+        if is_async:
+
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    params = self.extract_params_callback(kwargs)
+                except KeyError:
+                    return await func(*args, **kwargs)
 
-            # Send message if needed
-            if should_send:
+                # Check if we should send a message
+                should_send = False
                 if self.use_custom_handler:
-                    self.message_handler(*params)
+                    should_send = any(
+                        p is not None and p != '' for p in params
+                    )
                 else:
-                    # For built-in handler, provide defaults
-                    title, desc, attach = params
-                    self.message_handler(
-                        title or "Executing Tool",
-                        desc or f"Running {func.__name__}",
-                        attach or '',
+                    # For default handler, params
+                    # (title, description, attachment)
+                    should_send = bool(params[0]) or bool(params[1])
+
+                # Send message if needed (handle async properly)
+                if should_send:
+                    try:
+                        if self.use_custom_handler:
+                            # Check if message handler is async
+                            if inspect.iscoroutinefunction(
+                                self.message_handler
+                            ):
+                                await self.message_handler(*params)
+                            else:
+                                self.message_handler(*params)
+                        else:
+                            # For built-in handler, provide defaults
+                            title, desc, attach = params
+                            self.message_handler(
+                                title or "Executing Tool",
+                                desc or f"Running {func.__name__}",
+                                attach or '',
+                            )
+                    except Exception as msg_error:
+                        # Don't let message handler
+                        # errors break the main function
+                        logger.warning(f"Message handler error: {msg_error}")
+
+                # Execute the original function
+                # (kwargs have been modified to remove message params)
+                result = await func(*args, **kwargs)
+
+                return result
+        else:
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                # Extract parameters using the callback
+                # (this will modify kwargs by removing message params)
+                try:
+                    params = self.extract_params_callback(kwargs)
+                except KeyError:
+                    # If parameters are missing,
+                    # just execute the original function
+                    return func(*args, **kwargs)
+
+                # Check if we should send a message
+                should_send = False
+                if self.use_custom_handler:
+                    should_send = any(
+                        p is not None and p != '' for p in params
                     )
+                else:
+                    should_send = bool(params[0]) or bool(params[1])
 
-            # Execute the original function
-            result = func(*args, **kwargs)
+                # Send message if needed
+                if should_send:
+                    try:
+                        if self.use_custom_handler:
+                            self.message_handler(*params)
+                        else:
+                            # For built-in handler, provide defaults
+                            title, desc, attach = params
+                            self.message_handler(
+                                title or "Executing Tool",
+                                desc or f"Running {func.__name__}",
+                                attach or '',
+                            )
+                    except Exception as msg_error:
+                        logger.warning(f"Message handler error: {msg_error}")
+
+                result = func(*args, **kwargs)
 
-            return result
+                return result
 
         # Apply the new signature to the wrapper
         wrapper.__signature__ = new_sig  # type: ignore[attr-defined]
 
+        # Create a hybrid approach:
+        # store toolkit instance info but preserve calling behavior
+        # We'll use a property-like
+        # approach to make __self__ available when needed
+        if hasattr(func, '__self__'):
+            toolkit_instance = func.__self__
+
+            # Store the toolkit instance as an attribute
+            # Use setattr to avoid MyPy type checking issues
+            wrapper.__toolkit_instance__ = toolkit_instance  # type: ignore[attr-defined]
+
+            # Create a dynamic __self__ property
+            # that only appears during introspection
+            # but doesn't interfere with normal function calls
+            def get_self():
+                return toolkit_instance
+
+            # Only set __self__
+            # if we're being called in an introspection context
+            # (like from _clone_tools)
+            # Use setattr to avoid MyPy type checking issues
+            wrapper.__self__ = toolkit_instance  # type: ignore[attr-defined]
+
         # Enhance the docstring
         if func.__doc__:
             enhanced_doc = func.__doc__.rstrip()

{camel_ai-0.2.73a2.dist-info → camel_ai-0.2.73a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a2
+Version: 0.2.73a3
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.73a2.dist-info → camel_ai-0.2.73a3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=pn3-Lfew1wFDh_51dBOk0tY-qRlN-W_XoCGsZ9kOZ7o,901
+camel/__init__.py,sha256=LY1yvi28uSSDg8ifjgLeFiCqzATMOyd5fXqDmkOmEAo,901
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=WgEwael_eT6D-lVAKHpKIpwXSTjvLbny5jbV1Ab8lnA,5760
@@ -332,7 +332,7 @@ camel/toolkits/craw4ai_toolkit.py,sha256=av8mqY68QgMSm27htnSdq0aqE6z3yWMVDSrNafQ
 camel/toolkits/dappier_toolkit.py,sha256=OEHOYXX_oXhgbVtWYAy13nO9uXf9i5qEXSwY4PexNFg,8194
 camel/toolkits/data_commons_toolkit.py,sha256=aHZUSL1ACpnYGaf1rE2csVKTmXTmN8lMGRUBYhZ_YEk,14168
 camel/toolkits/edgeone_pages_mcp_toolkit.py,sha256=1TFpAGHUNLggFQeN1OEw7P5laijwnlrCkfxBtgxFuUY,2331
-camel/toolkits/excel_toolkit.py,sha256=9Uk5GLWl719c4W-NcGPJTNMtodAbEE5gUgLsFkIInbk,32564
+camel/toolkits/excel_toolkit.py,sha256=tQaonygk0yDTPZHWWQKG5osTN-R_EawR0bJIKLsLg08,35768
 camel/toolkits/file_write_toolkit.py,sha256=d8N8FfmK1fS13sY58PPhJh6M0vq6yh-s1-ltCZQJObg,37044
 camel/toolkits/function_tool.py,sha256=3_hE-Khqf556CeebchsPpjIDCynC6vKmUJLdh1EO_js,34295
 camel/toolkits/github_toolkit.py,sha256=iUyRrjWGAW_iljZVfNyfkm1Vi55wJxK6PsDAQs9pOag,13099
@@ -351,7 +351,7 @@ camel/toolkits/mcp_toolkit.py,sha256=da7QLwGKIKnKvMx5mOOiC56w0hKV1bvD1Z9PgrSHOtA
 camel/toolkits/memory_toolkit.py,sha256=TeKYd5UMwgjVpuS2orb-ocFL13eUNKujvrFOruDCpm8,4436
 camel/toolkits/meshy_toolkit.py,sha256=NbgdOBD3FYLtZf-AfonIv6-Q8-8DW129jsaP1PqI2rs,7126
 camel/toolkits/message_agent_toolkit.py,sha256=yWvAaxoxAvDEtD7NH7IkkHIyfWIYK47WZhn5E_RaxKo,22661
-camel/toolkits/message_integration.py,sha256=WdcoVoDAPwlvfXK26wHBf2q_IQCH4PQ_gJtyqUViVvE,23213
+camel/toolkits/message_integration.py,sha256=-dcf91DJzj8asXP2cc7mMy1BH2xzifhH-MMGr_nvJGw,28730
 camel/toolkits/mineru_toolkit.py,sha256=vRX9LholLNkpbJ6axfEN4pTG85aWb0PDmlVy3rAAXhg,6868
 camel/toolkits/networkx_toolkit.py,sha256=C7pUCZTzzGkFyqdkrmhRKpAHmHWfLKeuzYHC_BHPtbk,8826
 camel/toolkits/note_taking_toolkit.py,sha256=cp7uoSBMjiGy331Tdk2Bl6yqKSMGwws7rQJkq8tfTQs,10687
@@ -392,7 +392,7 @@ camel/toolkits/hybrid_browser_toolkit/__init__.py,sha256=vxjWhq7GjUKE5I9RGQU_Goi
 camel/toolkits/hybrid_browser_toolkit/config_loader.py,sha256=UwBh7wG4-owoI2VfiNMum0O7dPWMYiEDxQKtq_GazU4,6903
 camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py,sha256=gotOOlXJjfjv9Qnn89PLNhJ4_Rw_aMMU6gTJcG-uCf8,7938
 camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py,sha256=8ArSGFCx1bIrZR8cdRVUX6axy5Fxgk5ADEgiSrPQ_Bo,45269
-camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py,sha256=5wssGj2LvREtyl91lC5pTIb0G7DZlFvLT_Pn-7XPESY,18460
+camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py,sha256=gyJsqHDvvpXa86zxqn8nsitS0QYqwmIHGgvPmcxVsYc,20445
 camel/toolkits/hybrid_browser_toolkit/ts/package-lock.json,sha256=_-YE9S_C1XT59A6upQp9lLuZcC67cV9QlbwAsEKkfyw,156337
 camel/toolkits/hybrid_browser_toolkit/ts/package.json,sha256=pUQm0xwXR7ZyWNv6O2QtHW00agnfAoX9F_XGXZlAxl4,745
 camel/toolkits/hybrid_browser_toolkit/ts/tsconfig.json,sha256=SwpQnq4Q-rwRobF2iWrP96mgmgwaVPZEv-nii5QIYEU,523
@@ -467,7 +467,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.73a2.dist-info/METADATA,sha256=cZbuO7_djNwJRLDIsjoopizSes24a2pjAewf7XM-u0A,50334
-camel_ai-0.2.73a2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.73a2.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.73a2.dist-info/RECORD,,
+camel_ai-0.2.73a3.dist-info/METADATA,sha256=vy-EgY3IPDzVVc5UNfT7MQvrWqvpBZ1ZUPGQb-bXOrA,50334
+camel_ai-0.2.73a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.73a3.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.73a3.dist-info/RECORD,,