camel-ai 0.2.72a10__py3-none-any.whl → 0.2.73__py3-none-any.whl

camel/toolkits/terminal_toolkit.py

@@ -17,6 +17,7 @@ import os
 import platform
 import queue
 import shutil
+import signal
 import subprocess
 import sys
 import threading
@@ -42,7 +43,7 @@ class TerminalToolkit(BaseToolkit):
 
     Args:
         timeout (Optional[float]): The timeout for terminal operations.
-            (default: :obj:`None`)
+            (default: :obj:`20.0`)
         shell_sessions (Optional[Dict[str, Any]]): A dictionary to store
             shell session information. If :obj:`None`, an empty dictionary
             will be used. (default: :obj:`None`)
@@ -61,6 +62,10 @@ class TerminalToolkit(BaseToolkit):
             environment. (default: :obj:`False`)
         safe_mode (bool): Whether to enable safe mode to restrict
             operations. (default: :obj:`True`)
+        interactive (bool): Whether to use interactive mode for shell commands,
+            connecting them to the terminal's standard input. This is useful
+            for commands that require user input, like `ssh`. Interactive mode
+            is only supported on macOS and Linux. (default: :obj:`False`)
 
     Note:
         Most functions are compatible with Unix-based systems (macOS, Linux).
@@ -70,14 +75,17 @@ class TerminalToolkit(BaseToolkit):
 
     def __init__(
         self,
-        timeout: Optional[float] = None,
+        timeout: Optional[float] = 20.0,
         shell_sessions: Optional[Dict[str, Any]] = None,
         working_directory: Optional[str] = None,
         need_terminal: bool = True,
         use_shell_mode: bool = True,
         clone_current_env: bool = False,
         safe_mode: bool = True,
+        interactive: bool = False,
     ):
+        # Store timeout before calling super().__init__
+        self._timeout = timeout
         super().__init__(timeout=timeout)
         self.shell_sessions = shell_sessions or {}
         self.os_type = platform.system()
@@ -90,11 +98,13 @@ class TerminalToolkit(BaseToolkit):
         self.cloned_env_path = None
         self.use_shell_mode = use_shell_mode
         self._human_takeover_active = False
+        self.interactive = interactive
 
         self.python_executable = sys.executable
         self.is_macos = platform.system() == 'Darwin'
         self.initial_env_path: Optional[str] = None
         self.initial_env_prepared = False
+        self.uv_path: Optional[str] = None
 
         atexit.register(self.__del__)
 
@@ -197,37 +207,111 @@ class TerminalToolkit(BaseToolkit):
                 f"Creating new Python environment at: {self.cloned_env_path}\n"
             )
 
-            # Create virtual environment with pip
-            venv.create(self.cloned_env_path, with_pip=True)
+            # Try to use uv if available
+            if self._ensure_uv_available():
+                # Use uv to create environment with current Python version
+                uv_command = self.uv_path if self.uv_path else "uv"
 
-            # Ensure pip is properly available by upgrading it
-            if self.os_type == 'Windows':
-                python_path = os.path.join(
-                    self.cloned_env_path, "Scripts", "python.exe"
+                # Get current Python version
+                current_version = (
+                    f"{sys.version_info.major}.{sys.version_info.minor}"
                 )
-            else:
-                python_path = os.path.join(
-                    self.cloned_env_path, "bin", "python"
+
+                subprocess.run(
+                    [
+                        uv_command,
+                        "venv",
+                        "--python",
+                        current_version,
+                        self.cloned_env_path,
+                    ],
+                    check=True,
+                    capture_output=True,
+                    cwd=self.working_dir,
+                    timeout=300,
                 )
 
-            # Verify python executable exists
-            if os.path.exists(python_path):
-                # Use python -m pip to ensure pip is available
+                # Get the python path from the new environment
+                if self.os_type == 'Windows':
+                    python_path = os.path.join(
+                        self.cloned_env_path, "Scripts", "python.exe"
+                    )
+                else:
+                    python_path = os.path.join(
+                        self.cloned_env_path, "bin", "python"
+                    )
+
+                # Install pip and setuptools using uv
                 subprocess.run(
-                    [python_path, "-m", "pip", "install", "--upgrade", "pip"],
+                    [
+                        uv_command,
+                        "pip",
+                        "install",
+                        "--python",
+                        python_path,
+                        "pip",
+                        "setuptools",
+                        "wheel",
+                    ],
                     check=True,
                     capture_output=True,
                     cwd=self.working_dir,
-                    timeout=60,
+                    timeout=300,
                 )
+
                 self._update_terminal_output(
-                    "New Python environment created successfully with pip!\n"
+                    "[UV] Cloned Python environment created successfully!\n"
                 )
+
             else:
+                # Fallback to standard venv
                 self._update_terminal_output(
-                    f"Warning: Python executable not found at {python_path}\n"
+                    "Falling back to standard venv for cloning environment\n"
+                )
+
+                # Create virtual environment with pip. On macOS, use
+                # symlinks=False to avoid dyld library loading issues
+                venv.create(
+                    self.cloned_env_path, with_pip=True, symlinks=False
                 )
 
+                # Ensure pip is properly available by upgrading it
+                if self.os_type == 'Windows':
+                    python_path = os.path.join(
+                        self.cloned_env_path, "Scripts", "python.exe"
+                    )
+                else:
+                    python_path = os.path.join(
+                        self.cloned_env_path, "bin", "python"
+                    )
+
+                # Verify python executable exists
+                if os.path.exists(python_path):
+                    # Use python -m pip to ensure pip is available
+                    subprocess.run(
+                        [
+                            python_path,
+                            "-m",
+                            "pip",
+                            "install",
+                            "--upgrade",
+                            "pip",
+                        ],
+                        check=True,
+                        capture_output=True,
+                        cwd=self.working_dir,
+                        timeout=60,
+                    )
+                    self._update_terminal_output(
+                        "New Python environment created successfully "
+                        "with pip!\n"
+                    )
+                else:
+                    self._update_terminal_output(
+                        f"Warning: Python executable not found "
+                        f"at {python_path}\n"
+                    )
+
         except subprocess.CalledProcessError as e:
             error_msg = e.stderr.decode() if e.stderr else str(e)
             self._update_terminal_output(
@@ -252,6 +336,97 @@ class TerminalToolkit(BaseToolkit):
             or shutil.which("uv") is not None
         )
 
+    def _ensure_uv_available(self) -> bool:
+        r"""Ensure uv is available, installing it if necessary.
+
+        Returns:
+            bool: True if uv is available (either already installed or
+                successfully installed), False otherwise.
+        """
+        # Check if uv is already available
+        existing_uv = shutil.which("uv")
+        if existing_uv is not None:
+            self.uv_path = existing_uv
+            self._update_terminal_output(
+                f"uv is already available at: {self.uv_path}\n"
+            )
+            return True
+
+        try:
+            self._update_terminal_output("uv not found, installing...\n")
+
+            # Install uv using the official installer script
+            if self.os_type in ['Darwin', 'Linux']:
+                # Use curl to download and execute the installer
+                install_cmd = "curl -LsSf https://astral.sh/uv/install.sh | sh"
+                result = subprocess.run(
+                    install_cmd,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+
+                if result.returncode != 0:
+                    self._update_terminal_output(
+                        f"Failed to install uv: {result.stderr}\n"
+                    )
+                    return False
+
+                # Check if uv was installed in the expected location
+                home = os.path.expanduser("~")
+                uv_bin_path = os.path.join(home, ".cargo", "bin")
+                uv_executable = os.path.join(uv_bin_path, "uv")
+
+                if os.path.exists(uv_executable):
+                    # Store the full path to uv instead of modifying PATH
+                    self.uv_path = uv_executable
+                    self._update_terminal_output(
+                        f"uv installed successfully at: {self.uv_path}\n"
+                    )
+                    return True
+
+            elif self.os_type == 'Windows':
+                # Use PowerShell to install uv on Windows
+                install_cmd = (
+                    "powershell -ExecutionPolicy Bypass -c "
+                    "\"irm https://astral.sh/uv/install.ps1 | iex\""
+                )
+                result = subprocess.run(
+                    install_cmd,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+
+                if result.returncode != 0:
+                    self._update_terminal_output(
+                        f"Failed to install uv: {result.stderr}\n"
+                    )
+                    return False
+
+                # Check if uv was installed in the expected location on Windows
+                home = os.path.expanduser("~")
+                uv_bin_path = os.path.join(home, ".cargo", "bin")
+                uv_executable = os.path.join(uv_bin_path, "uv.exe")
+
+                if os.path.exists(uv_executable):
+                    # Store the full path to uv instead of modifying PATH
+                    self.uv_path = uv_executable
+                    self._update_terminal_output(
+                        f"uv installed successfully at: {self.uv_path}\n"
+                    )
+                    return True
+
+            self._update_terminal_output("Failed to verify uv installation\n")
+            return False
+
+        except Exception as e:
+            self._update_terminal_output(f"Error installing uv: {e!s}\n")
+            logger.error(f"Failed to install uv: {e}")
+            return False
+
     def _prepare_initial_environment(self):
         r"""Prepare initial environment with Python 3.10, pip, and other
         essential tools.
@@ -276,10 +451,14 @@ class TerminalToolkit(BaseToolkit):
             # Create the initial environment directory
             os.makedirs(self.initial_env_path, exist_ok=True)
 
-            # Check if we should use uv
-            if self._is_uv_environment():
+            # Try to ensure uv is available and use it preferentially
+            if self._ensure_uv_available():
                 self._setup_initial_env_with_uv()
             else:
+                # Fallback to venv if uv installation failed
+                self._update_terminal_output(
+                    "Falling back to standard venv for environment setup\n"
+                )
                 self._setup_initial_env_with_venv()
 
             self.initial_env_prepared = True
@@ -299,9 +478,18 @@ class TerminalToolkit(BaseToolkit):
             raise Exception("Initial environment path not set")
 
         try:
+            # Use the stored uv path if available, otherwise fall back to "uv"
+            uv_command = self.uv_path if self.uv_path else "uv"
+
             # Create virtual environment with Python 3.10 using uv
             subprocess.run(
-                ["uv", "venv", "--python", "3.10", self.initial_env_path],
+                [
+                    uv_command,
+                    "venv",
+                    "--python",
+                    "3.10",
+                    self.initial_env_path,
+                ],
                 check=True,
                 capture_output=True,
                 cwd=self.working_dir,
@@ -319,10 +507,17 @@ class TerminalToolkit(BaseToolkit):
                 )
 
             # Install essential packages using uv
-            essential_packages = ["pip", "setuptools", "wheel"]
+            essential_packages = [
+                "pip",
+                "setuptools",
+                "wheel",
+                "pyautogui",
+                "plotly",
+                "ffmpeg",
+            ]
             subprocess.run(
                 [
-                    "uv",
+                    uv_command,
                     "pip",
                     "install",
                     "--python",
@@ -356,10 +551,12 @@ class TerminalToolkit(BaseToolkit):
 
         try:
             # Create virtual environment with system Python
+            # On macOS, use symlinks=False to avoid dyld library loading issues
             venv.create(
                 self.initial_env_path,
                 with_pip=True,
                 system_site_packages=False,
+                symlinks=False,
             )
 
             # Get pip path
@@ -371,7 +568,14 @@ class TerminalToolkit(BaseToolkit):
                 pip_path = os.path.join(self.initial_env_path, "bin", "pip")
 
             # Upgrade pip and install essential packages
-            essential_packages = ["pip", "setuptools", "wheel"]
+            essential_packages = [
+                "pip",
+                "setuptools",
+                "wheel",
+                "pyautogui",
+                "plotly",
+                "ffmpeg",
+            ]
             subprocess.run(
                 [pip_path, "install", "--upgrade", *essential_packages],
                 check=True,
@@ -804,26 +1008,18 @@ class TerminalToolkit(BaseToolkit):
 
         return True, command
 
-    def shell_exec(
-        self, id: str, command: str, interactive: bool = False
-    ) -> str:
+    def shell_exec(self, id: str, command: str) -> str:
         r"""Executes a shell command in a specified session.
 
         This function creates and manages shell sessions to execute commands,
-        simulating a real terminal. It can run commands in both non-interactive
-        (capturing output) and interactive modes. Each session is identified by
-        a unique ID. If a session with the given ID does not exist, it will be
-        created.
+        simulating a real terminal. The behavior depends on the toolkit's
+        interactive mode setting. Each session is identified by a unique ID.
+        If a session with the given ID does not exist, it will be created.
 
         Args:
             id (str): A unique identifier for the shell session. This is used
                 to manage multiple concurrent shell processes.
             command (str): The shell command to be executed.
-            interactive (bool, optional): If `True`, the command runs in
-                interactive mode, connecting it to the terminal's standard
-                input. This is useful for commands that require user input,
-                like `ssh`. Defaults to `False`. Interactive mode is only
-                supported on macOS and Linux. (default: :obj:`False`)
 
         Returns:
             str: The standard output and standard error from the command. If an
@@ -831,8 +1027,8 @@ class TerminalToolkit(BaseToolkit):
                 returned.
 
         Note:
-            When `interactive` is set to `True`, this function may block if the
-            command requires input. In safe mode, some commands that are
+            When the toolkit is initialized with interactive mode, commands may
+            block if they require input. In safe mode, some commands that are
             considered dangerous are restricted.
         """
         error_msg = self._enforce_working_dir_for_execution(self.working_dir)
@@ -929,7 +1125,12 @@ class TerminalToolkit(BaseToolkit):
                 elif pip_path and command.startswith('pip'):
                     command = command.replace('pip', pip_path, 1)
 
-            if not interactive:
+            if not self.interactive:
+                # Use preexec_fn to create a new process group on Unix systems
+                preexec_fn = None
+                if self.os_type in ['Darwin', 'Linux']:
+                    preexec_fn = os.setsid
+
                 proc = subprocess.Popen(
                     command,
                     shell=True,
@@ -941,17 +1142,55 @@ class TerminalToolkit(BaseToolkit):
                     bufsize=1,
                     universal_newlines=True,
                     env=os.environ.copy(),
+                    preexec_fn=preexec_fn,
                 )
 
                 self.shell_sessions[id]["process"] = proc
                 self.shell_sessions[id]["running"] = True
-                stdout, stderr = proc.communicate()
-                output = stdout or ""
-                if stderr:
-                    output += f"\nStderr Output:\n{stderr}"
-                self.shell_sessions[id]["output"] = output
-                self._update_terminal_output(output + "\n")
-                return output
+                try:
+                    # Use the instance timeout if available
+                    stdout, stderr = proc.communicate(timeout=self.timeout)
+                    output = stdout or ""
+                    if stderr:
+                        output += f"\nStderr Output:\n{stderr}"
+                    self.shell_sessions[id]["output"] = output
+                    self.shell_sessions[id]["running"] = False
+                    self._update_terminal_output(output + "\n")
+                    return output
+                except subprocess.TimeoutExpired:
+                    # Kill the entire process group on Unix systems
+                    if self.os_type in ['Darwin', 'Linux']:
+                        try:
+                            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+                            # Give it a short time to terminate
+                            stdout, stderr = proc.communicate(timeout=1)
+                        except subprocess.TimeoutExpired:
+                            # Force kill the process group
+                            os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+                            stdout, stderr = proc.communicate()
+                        except ProcessLookupError:
+                            # Process already dead
+                            stdout, stderr = proc.communicate()
+                    else:
+                        # Windows fallback
+                        proc.terminate()
+                        try:
+                            stdout, stderr = proc.communicate(timeout=1)
+                        except subprocess.TimeoutExpired:
+                            proc.kill()
+                            stdout, stderr = proc.communicate()
+
+                    output = stdout or ""
+                    if stderr:
+                        output += f"\nStderr Output:\n{stderr}"
+                    error_msg = (
+                        f"\nCommand timed out after {self.timeout} seconds"
+                    )
+                    output += error_msg
+                    self.shell_sessions[id]["output"] = output
+                    self.shell_sessions[id]["running"] = False
+                    self._update_terminal_output(output + "\n")
+                    return output
 
             # Interactive mode with real-time streaming via PTY
             if self.os_type not in ['Darwin', 'Linux']:
@@ -1061,6 +1300,9 @@ class TerminalToolkit(BaseToolkit):
                 f"Detailed information: {detailed_error}"
             )
 
+    # Mark shell_exec to skip automatic timeout wrapping
+    shell_exec._manual_timeout = True  # type: ignore[attr-defined]
+
     def shell_view(self, id: str) -> str:
         r"""View the full output history of a specified shell session.
 

camel/toolkits/video_analysis_toolkit.py

@@ -97,7 +97,7 @@ class VideoAnalysisToolkit(BaseToolkit):
     r"""A class for analysing videos with vision-language model.
 
     Args:
-        download_directory (Optional[str], optional): The directory where the
+        working_directory (Optional[str], optional): The directory where the
             video will be downloaded to. If not provided, video will be stored
             in a temporary directory and will be cleaned up after use.
             (default: :obj:`None`)
@@ -123,7 +123,7 @@ class VideoAnalysisToolkit(BaseToolkit):
     @dependencies_required("ffmpeg", "scenedetect")
     def __init__(
         self,
-        download_directory: Optional[str] = None,
+        working_directory: Optional[str] = None,
         model: Optional[BaseModelBackend] = None,
         use_audio_transcription: bool = False,
         use_ocr: bool = False,
@@ -133,30 +133,30 @@ class VideoAnalysisToolkit(BaseToolkit):
         timeout: Optional[float] = None,
     ) -> None:
         super().__init__(timeout=timeout)
-        self._cleanup = download_directory is None
+        self._cleanup = working_directory is None
         self._temp_files: list[str] = []  # Track temporary files for cleanup
         self._use_audio_transcription = use_audio_transcription
         self._use_ocr = use_ocr
         self.output_language = output_language
         self.frame_interval = frame_interval
 
-        self._download_directory = Path(
-            download_directory or tempfile.mkdtemp()
+        self._working_directory = Path(
+            working_directory or tempfile.mkdtemp()
         ).resolve()
 
         self.video_downloader_toolkit = VideoDownloaderToolkit(
-            download_directory=str(self._download_directory),
+            working_directory=str(self._working_directory),
             cookies_path=cookies_path,
         )
 
         try:
-            self._download_directory.mkdir(parents=True, exist_ok=True)
+            self._working_directory.mkdir(parents=True, exist_ok=True)
         except OSError as e:
             raise ValueError(
-                f"Error creating directory {self._download_directory}: {e}"
+                f"Error creating directory {self._working_directory}: {e}"
             )
 
-        logger.info(f"Video will be downloaded to {self._download_directory}")
+        logger.info(f"Video will be downloaded to {self._working_directory}")
 
         self.vl_model = model
         # Ensure ChatAgent is initialized with a model if provided
@@ -206,16 +206,16 @@ class VideoAnalysisToolkit(BaseToolkit):
                     )
 
         # Clean up temporary directory if needed
-        if self._cleanup and os.path.exists(self._download_directory):
+        if self._cleanup and os.path.exists(self._working_directory):
             try:
                 import sys
 
                 if getattr(sys, 'modules', None) is not None:
                     import shutil
 
-                    shutil.rmtree(self._download_directory)
+                    shutil.rmtree(self._working_directory)
                     logger.debug(
-                        f"Removed temp directory: {self._download_directory}"
+                        f"Removed temp directory: {self._working_directory}"
                     )
             except (ImportError, AttributeError):
                 # Skip cleanup if interpreter is shutting down
@@ -223,7 +223,7 @@ class VideoAnalysisToolkit(BaseToolkit):
             except OSError as e:
                 logger.warning(
                     f"Failed to remove temporary directory "
-                    f"{self._download_directory}: {e}"
+                    f"{self._working_directory}: {e}"
                 )
 
     @dependencies_required("pytesseract", "cv2", "numpy")

camel/toolkits/video_download_toolkit.py

@@ -62,7 +62,7 @@ class VideoDownloaderToolkit(BaseToolkit):
     chunks.
 
     Args:
-        download_directory (Optional[str], optional): The directory where the
+        working_directory (Optional[str], optional): The directory where the
             video will be downloaded to. If not provided, video will be stored
             in a temporary directory and will be cleaned up after use.
             (default: :obj:`None`)
@@ -73,30 +73,30 @@ class VideoDownloaderToolkit(BaseToolkit):
     @dependencies_required("yt_dlp", "ffmpeg")
     def __init__(
         self,
-        download_directory: Optional[str] = None,
+        working_directory: Optional[str] = None,
         cookies_path: Optional[str] = None,
         timeout: Optional[float] = None,
     ) -> None:
         super().__init__(timeout=timeout)
-        self._cleanup = download_directory is None
+        self._cleanup = working_directory is None
         self._cookies_path = cookies_path
 
-        self._download_directory = Path(
-            download_directory or tempfile.mkdtemp()
+        self._working_directory = Path(
+            working_directory or tempfile.mkdtemp()
         ).resolve()
 
         try:
-            self._download_directory.mkdir(parents=True, exist_ok=True)
+            self._working_directory.mkdir(parents=True, exist_ok=True)
         except FileExistsError:
             raise ValueError(
-                f"{self._download_directory} is not a valid directory."
+                f"{self._working_directory} is not a valid directory."
             )
         except OSError as e:
             raise ValueError(
-                f"Error creating directory {self._download_directory}: {e}"
+                f"Error creating directory {self._working_directory}: {e}"
             )
 
-        logger.info(f"Video will be downloaded to {self._download_directory}")
+        logger.info(f"Video will be downloaded to {self._working_directory}")
 
     def __del__(self) -> None:
         r"""Deconstructor for the VideoDownloaderToolkit class.
@@ -111,7 +111,7 @@ class VideoDownloaderToolkit(BaseToolkit):
                 if getattr(sys, 'modules', None) is not None:
                     import shutil
 
-                    shutil.rmtree(self._download_directory, ignore_errors=True)
+                    shutil.rmtree(self._working_directory, ignore_errors=True)
             except (ImportError, AttributeError):
                 # Skip cleanup if interpreter is shutting down
                 pass
@@ -130,7 +130,7 @@ class VideoDownloaderToolkit(BaseToolkit):
         """
         import yt_dlp
 
-        video_template = self._download_directory / "%(title)s.%(ext)s"
+        video_template = self._working_directory / "%(title)s.%(ext)s"
         ydl_opts = {
             'format': 'bestvideo+bestaudio/best',
             'outtmpl': str(video_template),