camel-ai 0.2.41__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.41'
+__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,
             )
         )
@@ -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/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/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,

camel/toolkits/terminal_toolkit.py

@@ -12,9 +12,16 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import atexit
 import os
+import platform
+import queue
 import subprocess
-from typing import Any, Dict, List, Optional
+import sys
+import threading
+import venv
+from queue import Queue
+from typing import Any, Dict, List, Optional, Tuple
 
 from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
@@ -36,7 +43,19 @@ class TerminalToolkit(BaseToolkit):
         timeout (Optional[float]): The timeout for terminal operations.
         shell_sessions (Optional[Dict[str, Any]]): A dictionary to store
             shell session information. If None, an empty dictionary will be
-            used.
+            used. (default: :obj:`{}`)
+        working_dir (str): The working directory for operations.
+            If specified, all execution and write operations will be restricted
+            to this directory. Read operations can access paths outside this
+            directory.(default: :obj:`"./workspace"`)
+        need_terminal (bool): Whether to create a terminal interface.
+            (default: :obj:`True`)
+        use_shell_mode (bool): Whether to use shell mode for command execution.
+            (default: :obj:`True`)
+        clone_current_env (bool): Whether to clone the current Python
+            environment.(default: :obj:`False`)
+        safe_mode (bool): Whether to enable safe mode to restrict operations.
+            (default: :obj:`True`)
 
     Note:
         Most functions are compatible with Unix-based systems (macOS, Linux).
@@ -48,14 +67,260 @@ class TerminalToolkit(BaseToolkit):
         self,
         timeout: Optional[float] = None,
         shell_sessions: Optional[Dict[str, Any]] = None,
+        working_dir: str = "./workspace",
+        need_terminal: bool = True,
+        use_shell_mode: bool = True,
+        clone_current_env: bool = False,
+        safe_mode: bool = True,
     ):
-        import platform
-
         super().__init__(timeout=timeout)
         self.shell_sessions = shell_sessions or {}
-        self.os_type = (
-            platform.system()
-        )  # 'Windows', 'Darwin' (macOS), 'Linux'
+        self.os_type = platform.system()
+        self.output_queue: Queue[str] = Queue()
+        self.agent_queue: Queue[str] = Queue()
+        self.terminal_ready = threading.Event()
+        self.gui_thread = None
+        self.safe_mode = safe_mode
+
+        self.cloned_env_path = None
+        self.use_shell_mode = use_shell_mode
+
+        self.python_executable = sys.executable
+        self.is_macos = platform.system() == 'Darwin'
+
+        atexit.register(self.__del__)
+
+        if not os.path.exists(working_dir):
+            os.makedirs(working_dir, exist_ok=True)
+        self.working_dir = os.path.abspath(working_dir)
+        self._update_terminal_output(
+            f"Working directory set to: {self.working_dir}\n"
+        )
+        if self.safe_mode:
+            self._update_terminal_output(
+                "Safe mode enabled: Write operations can only "
+                "be performed within the working directory\n"
+            )
+
+        if clone_current_env:
+            self.cloned_env_path = os.path.join(self.working_dir, ".venv")
+            self._clone_current_environment()
+        else:
+            self.cloned_env_path = None
+
+        if need_terminal:
+            if self.is_macos:
+                # macOS uses non-GUI mode
+                logger.info("Detected macOS environment, using non-GUI mode")
+                self._setup_file_output()
+                self.terminal_ready.set()
+            else:
+                # Other platforms use normal GUI
+                self.gui_thread = threading.Thread(
+                    target=self._create_terminal, daemon=True
+                )
+                self.gui_thread.start()
+                self.terminal_ready.wait(timeout=5)
+
+    def _setup_file_output(self):
+        r"""Set up file output to replace GUI, using a fixed file to simulate
+        terminal.
+        """
+
+        self.log_file = os.path.join(os.getcwd(), "camel_terminal.txt")
+
+        if os.path.exists(self.log_file):
+            with open(self.log_file, "w") as f:
+                f.truncate(0)
+                f.write("CAMEL Terminal Session\n")
+                f.write("=" * 50 + "\n")
+                f.write(f"Working Directory: {os.getcwd()}\n")
+                f.write("=" * 50 + "\n\n")
+        else:
+            with open(self.log_file, "w") as f:
+                f.write("CAMEL Terminal Session\n")
+                f.write("=" * 50 + "\n")
+                f.write(f"Working Directory: {os.getcwd()}\n")
+                f.write("=" * 50 + "\n\n")
+
+        # Inform the user
+        logger.info(f"Terminal output redirected to: {self.log_file}")
+
+        def file_update(output: str):
+            try:
+                # Directly append to the end of the file
+                with open(self.log_file, "a") as f:
+                    f.write(output)
+                    # If the output does not end with a newline, add one
+                    if output and not output.endswith('\n'):
+                        f.write('\n')
+                # Ensure the agent also receives the output
+                self.agent_queue.put(output)
+            except Exception as e:
+                logger.error(f"Failed to write to terminal: {e}")
+
+        # Replace the update method
+        self._update_terminal_output = file_update
+
+    def _clone_current_environment(self):
+        r"""Create a new Python virtual environment."""
+        try:
+            if os.path.exists(self.cloned_env_path):
+                self._update_terminal_output(
+                    f"Using existing environment: {self.cloned_env_path}\n"
+                )
+                return
+
+            self._update_terminal_output(
+                f"Creating new Python environment at:{self.cloned_env_path}\n"
+            )
+
+            venv.create(self.cloned_env_path, with_pip=True)
+            self._update_terminal_output(
+                "New Python environment created successfully!\n"
+            )
+
+        except Exception as e:
+            self._update_terminal_output(
+                f"Failed to create environment: {e!s}\n"
+            )
+            logger.error(f"Failed to create environment: {e}")
+
+    def _create_terminal(self):
+        r"""Create a terminal GUI."""
+
+        try:
+            import tkinter as tk
+            from tkinter import scrolledtext
+
+            def update_terminal():
+                try:
+                    while True:
+                        output = self.output_queue.get_nowait()
+                        if isinstance(output, bytes):
+                            output = output.decode('utf-8', errors='replace')
+                        self.terminal.insert(tk.END, output)
+                        self.terminal.see(tk.END)
+                except queue.Empty:
+                    if hasattr(self, 'root') and self.root:
+                        self.root.after(100, update_terminal)
+
+            self.root = tk.Tk()
+            self.root.title(f"{self.os_type} Terminal")
+
+            self.root.geometry("800x600")
+            self.root.minsize(400, 300)
+
+            self.terminal = scrolledtext.ScrolledText(
+                self.root,
+                wrap=tk.WORD,
+                bg='black',
+                fg='white',
+                font=('Consolas', 10),
+                insertbackground='white',  # Cursor color
+            )
+            self.terminal.pack(fill=tk.BOTH, expand=True)
+
+            # Set the handling for closing the window
+            def on_closing():
+                self.root.quit()
+                self.root.destroy()
+                self.root = None
+
+            self.root.protocol("WM_DELETE_WINDOW", on_closing)
+
+            # Start updating
+            update_terminal()
+
+            # Mark the terminal as ready
+            self.terminal_ready.set()
+
+            # Start the main loop
+            self.root.mainloop()
+
+        except Exception as e:
+            logger.error(f"Failed to create terminal: {e}")
+            self.terminal_ready.set()
+
+    def _update_terminal_output(self, output: str):
+        r"""Update terminal output and send to agent.
+
+        Args:
+            output (str): The output to be sent to the agent
+        """
+        try:
+            # If it is macOS , only write to file
+            if self.is_macos:
+                if hasattr(self, 'log_file'):
+                    with open(self.log_file, "a") as f:
+                        f.write(output)
+                # Ensure the agent also receives the output
+                self.agent_queue.put(output)
+                return
+
+            # For other cases, try to update the GUI (if it exists)
+            if hasattr(self, 'root') and self.root:
+                self.output_queue.put(output)
+
+            # Always send to agent queue
+            self.agent_queue.put(output)
+
+        except Exception as e:
+            logger.error(f"Failed to update terminal output: {e}")
+
+    def _is_path_within_working_dir(self, path: str) -> bool:
+        r"""Check if the path is within the working directory.
+
+        Args:
+            path (str): The path to check
+
+        Returns:
+            bool: Returns True if the path is within the working directory,
+                otherwise returns False
+        """
+        abs_path = os.path.abspath(path)
+        return abs_path.startswith(self.working_dir)
+
+    def _enforce_working_dir_for_execution(self, path: str) -> Optional[str]:
+        r"""Enforce working directory restrictions, return error message
+        if execution path is not within the working directory.
+
+        Args:
+            path (str): The path to be used for executing operations
+
+        Returns:
+            Optional[str]: Returns error message if the path is not within
+                the working directory, otherwise returns None
+        """
+        if not self._is_path_within_working_dir(path):
+            return (
+                f"Operation restriction: Execution path {path} must "
+                f"be within working directory {self.working_dir}"
+            )
+        return None
+
+    def _copy_external_file_to_workdir(
+        self, external_file: str
+    ) -> Optional[str]:
+        r"""Copy external file to working directory.
+
+        Args:
+            external_file (str): The path of the external file
+
+        Returns:
+            Optional[str]: New path after copying to the working directory,
+                returns None on failure
+        """
+        try:
+            import shutil
+
+            filename = os.path.basename(external_file)
+            new_path = os.path.join(self.working_dir, filename)
+            shutil.copy2(external_file, new_path)
+            return new_path
+        except Exception as e:
+            logger.error(f"Failed to copy file: {e}")
+            return None
 
     def file_find_in_content(
         self, file: str, regex: str, sudo: bool = False
@@ -72,6 +337,7 @@ class TerminalToolkit(BaseToolkit):
         Returns:
             str: Matching content found in the file.
         """
+
         if not os.path.exists(file):
             return f"File not found: {file}"
 
@@ -80,6 +346,9 @@ class TerminalToolkit(BaseToolkit):
 
         command = []
         if sudo:
+            error_msg = self._enforce_working_dir_for_execution(file)
+            if error_msg:
+                return error_msg
             command.extend(["sudo"])
 
         if self.os_type in ['Darwin', 'Linux']:  # macOS or Linux
@@ -119,38 +388,283 @@ class TerminalToolkit(BaseToolkit):
         else:  # Windows
             # For Windows, we use dir command with /s for recursive search
             # and /b for bare format
+
             pattern = glob
             file_path = os.path.join(path, pattern).replace('/', '\\')
             command.extend(["cmd", "/c", "dir", "/s", "/b", file_path])
 
         try:
             result = subprocess.run(
-                command, check=False, capture_output=True, text=True
+                command,
+                check=False,
+                capture_output=True,
+                text=True,
+                shell=False,
             )
-            return result.stdout.strip()
+
+            output = result.stdout.strip()
+            if self.os_type == 'Windows':
+                output = output.replace('\\', '/')
+            return output
         except subprocess.SubprocessError as e:
             logger.error(f"Error finding files by name: {e}")
             return f"Error: {e!s}"
 
-    def shell_exec(self, id: str, exec_dir: str, command: str) -> str:
-        r"""Execute commands in a specified shell session.
+    def _sanitize_command(self, command: str, exec_dir: str) -> Tuple:
+        r"""Check and modify command to ensure safety.
+
+        Args:
+            command (str): The command to check
+            exec_dir (str): The directory to execute the command in
+
+        Returns:
+            Tuple: (is safe, modified command or error message)
+        """
+        if not self.safe_mode:
+            return True, command
+
+        if not command or command.strip() == "":
+            return False, "Empty command"
+
+        # Use shlex for safer command parsing
+        import shlex
+
+        try:
+            parts = shlex.split(command)
+        except ValueError as e:
+            # Handle malformed commands (e.g., unbalanced quotes)
+            return False, f"Invalid command format: {e}"
+
+        if not parts:
+            return False, "Empty command"
+
+        # Get base command
+        base_cmd = parts[0].lower()
+
+        # Handle special commands
+        if base_cmd in ['cd', 'chdir']:
+            # Check if cd command attempts to leave the working directory
+            if len(parts) > 1:
+                target_dir = parts[1].strip('"\'')
+                if (
+                    target_dir.startswith('/')
+                    or target_dir.startswith('\\')
+                    or ':' in target_dir
+                ):
+                    # Absolute path
+                    abs_path = os.path.abspath(target_dir)
+                else:
+                    # Relative path
+                    abs_path = os.path.abspath(
+                        os.path.join(exec_dir, target_dir)
+                    )
+
+                if not self._is_path_within_working_dir(abs_path):
+                    return False, (
+                        f"Safety restriction: Cannot change to directory "
+                        f"outside of working directory {self.working_dir}"
+                    )
+
+        # Check file operation commands
+        elif base_cmd in [
+            'rm',
+            'del',
+            'rmdir',
+            'rd',
+            'deltree',
+            'erase',
+            'unlink',
+            'shred',
+            'srm',
+            'wipe',
+            'remove',
+        ]:
+            # Check targets of delete commands
+            for _, part in enumerate(parts[1:], 1):
+                if part.startswith('-') or part.startswith(
+                    '/'
+                ):  # Skip options
+                    continue
+
+                target = part.strip('"\'')
+                if (
+                    target.startswith('/')
+                    or target.startswith('\\')
+                    or ':' in target
+                ):
+                    # Absolute path
+                    abs_path = os.path.abspath(target)
+                else:
+                    # Relative path
+                    abs_path = os.path.abspath(os.path.join(exec_dir, target))
+
+                if not self._is_path_within_working_dir(abs_path):
+                    return False, (
+                        f"Safety restriction: Cannot delete files outside "
+                        f"of working directory {self.working_dir}"
+                    )
+
+        # Check write/modify commands
+        elif base_cmd in [
+            'touch',
+            'mkdir',
+            'md',
+            'echo',
+            'cat',
+            'cp',
+            'copy',
+            'mv',
+            'move',
+            'rename',
+            'ren',
+            'write',
+            'output',
+        ]:
+            # Check for redirection symbols
+            full_cmd = command.lower()
+            if '>' in full_cmd:
+                # Find the file path after redirection
+                redirect_parts = command.split('>')
+                if len(redirect_parts) > 1:
+                    output_file = (
+                        redirect_parts[1].strip().split()[0].strip('"\'')
+                    )
+                    if (
+                        output_file.startswith('/')
+                        or output_file.startswith('\\')
+                        or ':' in output_file
+                    ):
+                        # Absolute path
+                        abs_path = os.path.abspath(output_file)
+                    else:
+                        # Relative path
+                        abs_path = os.path.abspath(
+                            os.path.join(exec_dir, output_file)
+                        )
+
+                    if not self._is_path_within_working_dir(abs_path):
+                        return False, (
+                            f"Safety restriction: Cannot write to file "
+                            f"outside of working directory {self.working_dir}"
+                        )
+
+            # For cp/mv commands, check target paths
+            if base_cmd in ['cp', 'copy', 'mv', 'move']:
+                # Simple handling, assuming the last parameter is the target
+                if len(parts) > 2:
+                    target = parts[-1].strip('"\'')
+                    if (
+                        target.startswith('/')
+                        or target.startswith('\\')
+                        or ':' in target
+                    ):
+                        # Absolute path
+                        abs_path = os.path.abspath(target)
+                    else:
+                        # Relative path
+                        abs_path = os.path.abspath(
+                            os.path.join(exec_dir, target)
+                        )
+
+                    if not self._is_path_within_working_dir(abs_path):
+                        return False, (
+                            f"Safety restriction: Cannot write to file "
+                            f"outside of working directory {self.working_dir}"
+                        )
+
+        # Check dangerous commands
+        elif base_cmd in [
+            'sudo',
+            'su',
+            'chmod',
+            'chown',
+            'chgrp',
+            'passwd',
+            'mkfs',
+            'fdisk',
+            'dd',
+            'shutdown',
+            'reboot',
+            'halt',
+            'poweroff',
+            'init',
+        ]:
+            return False, (
+                f"Safety restriction: Command '{base_cmd}' may affect system "
+                f"security and is prohibited"
+            )
+
+        # Check network commands
+        elif base_cmd in ['ssh', 'telnet', 'ftp', 'sftp', 'nc', 'netcat']:
+            return False, (
+                f"Safety restriction: Network command '{base_cmd}' "
+                f"is prohibited"
+            )
+
+        # Add copy functionality - copy from external to working directory
+        elif base_cmd == 'safecopy':
+            # Custom command: safecopy <source file> <target file>
+            if len(parts) != 3:
+                return False, "Usage: safecopy <source file> <target file>"
+
+            source = parts[1].strip('\'"')
+            target = parts[2].strip('\'"')
+
+            # Check if source file exists
+            if not os.path.exists(source):
+                return False, f"Source file does not exist: {source}"
+
+            # Ensure target is within working directory
+            if (
+                target.startswith('/')
+                or target.startswith('\\')
+                or ':' in target
+            ):
+                # Absolute path
+                abs_target = os.path.abspath(target)
+            else:
+                # Relative path
+                abs_target = os.path.abspath(os.path.join(exec_dir, target))
+
+            if not self._is_path_within_working_dir(abs_target):
+                return False, (
+                    f"Safety restriction: Target file must be within "
+                    f"working directory {self.working_dir}"
+                )
+
+            # Replace with safe copy command
+            if self.os_type == 'Windows':
+                return True, f"copy \"{source}\" \"{abs_target}\""
+            else:
+                return True, f"cp \"{source}\" \"{abs_target}\""
+
+        return True, command
+
+    def shell_exec(self, id: str, command: str) -> str:
+        r"""Execute commands. This can be used to execute various commands,
+        such as writing code, executing code, and running commands.
 
         Args:
             id (str): Unique identifier of the target shell session.
-            exec_dir (str): Working directory for command execution (must use
-                absolute path).
             command (str): Shell command to execute.
 
         Returns:
             str: Output of the command execution or error message.
         """
-        if not os.path.isabs(exec_dir):
-            return f"exec_dir must be an absolute path: {exec_dir}"
+        # Command execution must be within the working directory
+        error_msg = self._enforce_working_dir_for_execution(self.working_dir)
+        if error_msg:
+            return error_msg
 
-        if not os.path.exists(exec_dir):
-            return f"Directory not found: {exec_dir}"
+        if self.safe_mode:
+            is_safe, sanitized_command = self._sanitize_command(
+                command, self.working_dir
+            )
+            if not is_safe:
+                return f"Command rejected: {sanitized_command}"
+            command = sanitized_command
 
-        # If the session doesn't exist, create a new one
+        # If the session does not exist, create a new session
         if id not in self.shell_sessions:
             self.shell_sessions[id] = {
                 "process": None,
@@ -159,48 +673,97 @@ class TerminalToolkit(BaseToolkit):
             }
 
         try:
-            # Execute the command in the specified directory
-            process = subprocess.Popen(
-                command,
-                shell=True,
-                cwd=exec_dir,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                stdin=subprocess.PIPE,
-                text=False,
-            )
-
-            # Store the process and mark as running
-            self.shell_sessions[id]["process"] = process
-            self.shell_sessions[id]["running"] = True
-            self.shell_sessions[id]["output"] = ""
+            # First, log the command to be executed
+            self._update_terminal_output(f"\n$ {command}\n")
+
+            if command.startswith('python') or command.startswith('pip'):
+                if self.cloned_env_path:
+                    if self.os_type == 'Windows':
+                        base_path = os.path.join(
+                            self.cloned_env_path, "Scripts"
+                        )
+                        python_path = os.path.join(base_path, "python.exe")
+                        pip_path = os.path.join(base_path, "pip.exe")
+                    else:
+                        base_path = os.path.join(self.cloned_env_path, "bin")
+                        python_path = os.path.join(base_path, "python")
+                        pip_path = os.path.join(base_path, "pip")
+                else:
+                    python_path = self.python_executable
+                    pip_path = f'"{python_path}" -m pip'
+
+                if command.startswith('python'):
+                    command = command.replace('python', f'"{python_path}"', 1)
+                elif command.startswith('pip'):
+                    command = command.replace('pip', pip_path, 1)
+
+            if self.is_macos:
+                # Type safe version - macOS uses subprocess.run
+                process = subprocess.run(
+                    command,
+                    shell=True,
+                    cwd=self.working_dir,
+                    capture_output=True,
+                    text=True,
+                    env=os.environ.copy(),
+                )
 
-            # Get initial output (non-blocking)
-            stdout, stderr = "", ""
-            try:
-                if process.stdout:
-                    stdout = process.stdout.read().decode('utf-8')
+                # Process the output
+                output = process.stdout or ""
                 if process.stderr:
-                    stderr = process.stderr.read().decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error reading initial output: {e}")
-                return f"Error: {e!s}"
+                    output += f"\nStderr Output:\n{process.stderr}"
+
+                # Update session information and terminal
+                self.shell_sessions[id]["output"] = output
+                self._update_terminal_output(output + "\n")
+
+                return output
+
+            else:
+                # Non-macOS systems use the Popen method
+                proc = subprocess.Popen(
+                    command,
+                    shell=True,
+                    cwd=self.working_dir,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    stdin=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    env=os.environ.copy(),
+                )
 
-            output = stdout
-            if stderr:
-                output += f"\nErrors:\n{stderr}"
+                # Store the process and mark it as running
+                self.shell_sessions[id]["process"] = proc
+                self.shell_sessions[id]["running"] = True
 
-            self.shell_sessions[id]["output"] = output
-            return (
-                f"Command started in session '{id}'. Initial output: {output}"
-            )
+                # Get output
+                stdout, stderr = proc.communicate()
 
-        except subprocess.SubprocessError as e:
-            self.shell_sessions[id]["running"] = False
-            error_msg = f"Error executing command: {e}"
-            self.shell_sessions[id]["output"] = error_msg
+                output = stdout or ""
+                if stderr:
+                    output += f"\nStderr Output:\n{stderr}"
+
+                # Update session information and terminal
+                self.shell_sessions[id]["output"] = output
+                self._update_terminal_output(output + "\n")
+
+                return output
+
+        except Exception as e:
+            error_msg = f"Command execution error: {e!s}"
             logger.error(error_msg)
-            return error_msg
+            self._update_terminal_output(f"\nError: {error_msg}\n")
+
+            # More detailed error information
+            import traceback
+
+            detailed_error = traceback.format_exc()
+            return (
+                f"Error: {error_msg}\n\n"
+                f"Detailed information: {detailed_error}"
+            )
 
     def shell_view(self, id: str) -> str:
         r"""View the content of a specified shell session.
@@ -215,50 +778,29 @@ class TerminalToolkit(BaseToolkit):
             return f"Shell session not found: {id}"
 
         session = self.shell_sessions[id]
-        process = session.get("process")
 
-        if process is None:
-            return f"No active process in session '{id}'"
+        try:
+            # Check process status
+            if session["process"].poll() is not None:
+                session["running"] = False
 
-        # Try to get any new output
-        if session["running"] and process.poll() is None:
+            # Collect all new output from agent queue
+            new_output = ""
             try:
-                # Non-blocking read from stdout/stderr
-                stdout_data, stderr_data = "", ""
-                if process.stdout and process.stdout.readable():
-                    stdout_data = process.stdout.read1().decode('utf-8')
-                if process.stderr and process.stderr.readable():
-                    stderr_data = process.stderr.read1().decode('utf-8')
-
-                if stdout_data:
-                    session["output"] += stdout_data
-                if stderr_data:
-                    session["output"] += f"\nErrors:\n{stderr_data}"
-            except Exception as e:
-                logger.error(f"Error getting process output: {e}")
-                return f"Error: {e!s}"
+                while True:
+                    output = self.agent_queue.get_nowait()
+                    new_output += output
+                    session["output"] += output
+            except queue.Empty:
+                pass
 
-        # Check if the process has completed
-        if process.poll() is not None and session["running"]:
-            try:
-                # Get remaining output if any
-                stdout_data, stderr_data = "", ""
-                if process.stdout and process.stdout.readable():
-                    stdout_data = process.stdout.read().decode('utf-8')
-                if process.stderr and process.stderr.readable():
-                    stderr_data = process.stderr.read().decode('utf-8')
-
-                if stdout_data:
-                    session["output"] += stdout_data
-                if stderr_data:
-                    session["output"] += f"\nErrors:\n{stderr_data}"
-            except Exception as e:
-                logger.error(f"Error getting final process output: {e}")
-                return f"Error: {e!s}"
-            finally:
-                session["running"] = False
+            return new_output or session["output"]
 
-        return session["output"]
+        except Exception as e:
+            error_msg = f"Error reading terminal output: {e}"
+            self._update_terminal_output(f"\nError: {error_msg}\n")
+            logger.error(error_msg)
+            return f"Error: {e!s}"
 
     def shell_wait(self, id: str, seconds: Optional[int] = None) -> str:
         r"""Wait for the running process in a specified shell session to
@@ -281,33 +823,40 @@ class TerminalToolkit(BaseToolkit):
         if process is None:
             return f"No active process in session '{id}'"
 
-        if not session["running"]:
+        if not session["running"] or process.poll() is not None:
             return f"Process in session '{id}' is not running"
 
         try:
-            # Use communicate with timeout
-            stdout, stderr = process.communicate(timeout=seconds)
-
-            if stdout:
-                stdout_str = (
-                    stdout.decode('utf-8')
-                    if isinstance(stdout, bytes)
-                    else stdout
+            if hasattr(process, 'communicate'):
+                # Use communicate with timeout
+                stdout, stderr = process.communicate(timeout=seconds)
+
+                if stdout:
+                    stdout_str = (
+                        stdout.decode('utf-8')
+                        if isinstance(stdout, bytes)
+                        else stdout
+                    )
+                    session["output"] += stdout_str
+                if stderr:
+                    stderr_str = (
+                        stderr.decode('utf-8')
+                        if isinstance(stderr, bytes)
+                        else stderr
+                    )
+                    if stderr_str:
+                        session["output"] += f"\nStderr Output:\n{stderr_str}"
+
+                session["running"] = False
+                return (
+                    f"Process completed in session '{id}'. "
+                    f"Output: {session['output']}"
                 )
-                session["output"] += stdout_str
-            if stderr:
-                stderr_str = (
-                    stderr.decode('utf-8')
-                    if isinstance(stderr, bytes)
-                    else stderr
+            else:
+                return (
+                    f"Process already completed in session '{id}'. "
+                    f"Output: {session['output']}"
                 )
-                session["output"] += f"\nErrors:\n{stderr_str}"
-
-            session["running"] = False
-            return (
-                f"Process completed in session '{id}'. "
-                f"Output: {session['output']}"
-            )
 
         except subprocess.TimeoutExpired:
             return (
@@ -404,6 +953,71 @@ class TerminalToolkit(BaseToolkit):
             logger.error(f"Error killing process: {e}")
             return f"Error killing process: {e!s}"
 
+    def __del__(self):
+        r"""Clean up resources when the object is being destroyed.
+        Terminates all running processes and closes any open file handles.
+        """
+        # Log that cleanup is starting
+        logger.info("TerminalToolkit cleanup initiated")
+
+        # Clean up all processes in shell sessions
+        for session_id, session in self.shell_sessions.items():
+            process = session.get("process")
+            if process is not None and session.get("running", False):
+                try:
+                    logger.info(
+                        f"Terminating process in session '{session_id}'"
+                    )
+
+                    # Close process input/output streams if open
+                    if (
+                        hasattr(process, 'stdin')
+                        and process.stdin
+                        and not process.stdin.closed
+                    ):
+                        process.stdin.close()
+
+                    # Terminate the process
+                    process.terminate()
+                    try:
+                        # Give the process a short time to terminate gracefully
+                        process.wait(timeout=3)
+                    except subprocess.TimeoutExpired:
+                        # Force kill if the process doesn't terminate
+                        # gracefully
+                        logger.warning(
+                            f"Process in session '{session_id}' did not "
+                            f"terminate gracefully, forcing kill"
+                        )
+                        process.kill()
+
+                    # Mark the session as not running
+                    session["running"] = False
+
+                except Exception as e:
+                    logger.error(
+                        f"Error cleaning up process in session "
+                        f"'{session_id}': {e}"
+                    )
+
+        # Close file output if it exists
+        if hasattr(self, 'log_file') and self.is_macos:
+            try:
+                logger.info(f"Final terminal log saved to: {self.log_file}")
+            except Exception as e:
+                logger.error(f"Error logging file information: {e}")
+
+        # Clean up GUI resources if they exist
+        if hasattr(self, 'root') and self.root:
+            try:
+                logger.info("Closing terminal GUI")
+                self.root.quit()
+                self.root.destroy()
+            except Exception as e:
+                logger.error(f"Error closing terminal GUI: {e}")
+
+        logger.info("TerminalToolkit cleanup completed")
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the functions
         in the toolkit.

{camel_ai-0.2.41.dist-info → camel_ai-0.2.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.41
+Version: 0.2.42
 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.41.dist-info → camel_ai-0.2.42.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=Pvojrkcw9OdbaLHL6wyoc5VwLbd_tJsRg58wVSrP2cs,912
+camel/__init__.py,sha256=OFoHvtZQPjUxj6ga19ljZ11Bxul4-gtgGIZnBFLOBvU,912
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=9X09UmxI2JqQnhrFfnZ3B9EzFmVfdSWQcjLWTIXKXe0,4962
 camel/logger.py,sha256=rZVeOVYuQ9RYJ5Tqyv0usqy0g4zaVEq4qSfZ9nd2640,5755
@@ -7,7 +7,7 @@ camel/agents/__init__.py,sha256=OEWDfxima22hjSZWgIu6sn9O_QKBr6cpS8b1Jywou0A,1596
 camel/agents/_types.py,sha256=ryPRmEXnpNtbFT23GoAcwK-zxWWsIOqYu64mxMx_PhI,1430
 camel/agents/_utils.py,sha256=AR7Qqgbkmn4X2edYUQf1rdksGUyV5hm3iK1z-Dn0Mcg,6266
 camel/agents/base.py,sha256=c4bJYL3G3Z41SaFdMPMn8ZjLdFiFaVOFO6EQIfuCVR8,1124
-camel/agents/chat_agent.py,sha256=WfHK6ZNVxnI-AaseWVNORAUlinCobHsByGu0ZSYIr2M,51267
+camel/agents/chat_agent.py,sha256=74Wd9ESQqepLrGcJIo0lU-5QAHCHIB7zS0-NiqiC7HA,52035
 camel/agents/critic_agent.py,sha256=qFVlHlQo0CVgmPWfWYLT8_oP_KyzCLFsQw_nN_vu5Bs,7487
 camel/agents/deductive_reasoner_agent.py,sha256=6BZGaq1hR6hKJuQtOfoYQnk_AkZpw_Mr7mUy2MspQgs,13540
 camel/agents/embodied_agent.py,sha256=XBxBu5ZMmSJ4B2U3Z7SMwvLlgp6yNpaBe8HNQmY9CZA,7536
@@ -106,7 +106,7 @@ camel/embeddings/vlm_embedding.py,sha256=HZFdcz1YzkFPzMj45_jaCVmDQJyccoXN561aLWl
 camel/environments/__init__.py,sha256=nWFEYK-QcRX0WskLVsXn4iP_pK2liL-iHKG7DSO0zTU,969
 camel/environments/models.py,sha256=jVcCyU7xObKoWPnkshmPqyyKi3AOiMVVtUZA-tWEYUU,4194
 camel/environments/multi_step.py,sha256=rEEMMHip5ZVEWpNj7miws5wALlujtUbFZkWDsy7ofHM,8360
-camel/environments/single_step.py,sha256=JtFH17v3KM5aRjP_WzNXGCvRx1N5ryTZm0voZgPFAkw,18855
+camel/environments/single_step.py,sha256=ELZ5GViw9eFCjQMytPMaLWHbAZZAqUCmNsk9h6qbggU,19713
 camel/extractors/__init__.py,sha256=lgtDl8zWvN826fJVKqRv05w556YZ-EdrHwdzKphywgA,1097
 camel/extractors/base.py,sha256=3jvuZpq27nlADDCX3GfubOpeb_zt-E9rzxF3x4lYm8s,10404
 camel/extractors/python_strategies.py,sha256=k8q4BIAhPZnCSN2LqPaZVrhF56y3Y4cZ6ddn79jcIXE,7825
@@ -180,7 +180,7 @@ camel/models/sglang_model.py,sha256=kdF-qShOH4j5lkuC2JEzUByuSoKtCFHdrIpAdbpR2Gg,
 camel/models/siliconflow_model.py,sha256=c40e0SQjHUNjr1ttJTTRTylRiNsPK_idP7Pa2iZr36g,6041
 camel/models/stub_model.py,sha256=JvjeEkXS7RMcR_UA_64a3T6S0QALUhOaMQs-aI7Etug,5955
 camel/models/togetherai_model.py,sha256=nV6ZqOrwEK6oNU1gTJlPfJDQbd9Mcl4GWkbqYnGPCQ0,7049
-camel/models/vllm_model.py,sha256=QZU7K6exbvEVVG8s50vxkSBQ-ppYLe-gF23-a6_XbnI,8098
+camel/models/vllm_model.py,sha256=lbcflI19mnvMt62hvpdDpfIJqYo0fTsd-pEZC_H-akA,8826
 camel/models/volcano_model.py,sha256=inYDiKOfGvq8o3XW4KVQIrXiZOhXQfB4HfCHGCWHPKs,3792
 camel/models/yi_model.py,sha256=sg7qOzvWZlGeKmlvA4kvZSWwMxTBo0-qgvEVjBalXcE,6572
 camel/models/zhipuai_model.py,sha256=JtMOTDsJIteZBPdIAwkeyUoAoh3O0dseaqjikiwjIfM,6909
@@ -312,7 +312,7 @@ camel/toolkits/semantic_scholar_toolkit.py,sha256=Rh7eA_YPxV5pvPIzhjjvpr3vtlaCni
 camel/toolkits/slack_toolkit.py,sha256=F1Xn2_Jmnv-1SdBnCNg3MI3RGwjZ7ZDWiNZjFJJS6x8,10791
 camel/toolkits/stripe_toolkit.py,sha256=07swo5znGTnorafC1uYLKB4NRcJIOPOx19J7tkpLYWk,10102
 camel/toolkits/sympy_toolkit.py,sha256=dkzGp7C7Oy-qP1rVziEk_ZOPRb37d5LoI7JKCLiTEo4,33758
-camel/toolkits/terminal_toolkit.py,sha256=kU6eOX9Ngysjh42jlgNyWhHYtDqf2CfZJH6bdwhSw-s,15228
+camel/toolkits/terminal_toolkit.py,sha256=gupuTvNkwnFzcFwDB_irSJ9-dXRr8yEAsYq5ChEkkHg,37230
 camel/toolkits/thinking_toolkit.py,sha256=NyA6rDFG-WbCNt7NFODBTpqOIDtP6he6GhnZpPlA2To,8001
 camel/toolkits/twitter_toolkit.py,sha256=j14Hxpt4XTEOF6dWpGm6Ot_vkYT7WOiLrUa1d2JT05U,15850
 camel/toolkits/video_analysis_toolkit.py,sha256=EqZnut9p0W5bgF1YpdGoaRJFDLHM2Ls8i9ApTQz44tA,15088
@@ -368,7 +368,7 @@ camel/verifiers/base.py,sha256=SQGZPP6p08q4Qmpr1vD-eb0UxBwkl1hpZSm19yV2wWo,14866
 camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo0y4,6875
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/python_verifier.py,sha256=o1VVINq4YQqNPz8h1FiZ7v2dMBN3wlH6AsRWPqN0iGQ,18037
-camel_ai-0.2.41.dist-info/METADATA,sha256=nZHt9rZqnrURzdvTIMWAPIGpKbo60IVfGFu7Za_F8Jo,42033
-camel_ai-0.2.41.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.41.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.41.dist-info/RECORD,,
+camel_ai-0.2.42.dist-info/METADATA,sha256=Yi_gfzN4krlk4P1Ek1XKLMuXldj0Xwu5TdddMd-pQqc,42033
+camel_ai-0.2.42.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.42.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.42.dist-info/RECORD,,