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

camel/toolkits/slack_toolkit.py

@@ -128,18 +128,15 @@ class SlackToolkit(BaseToolkit):
             return f"Error creating conversation: {e.response['error']}"
 
     def join_slack_channel(self, channel_id: str) -> str:
-        r"""Joins an existing Slack channel.
+        r"""Joins an existing Slack channel. When use this function you must
+        call `get_slack_channel_information` function first to get the
+        `channel id`.
 
         Args:
             channel_id (str): The ID of the Slack channel to join.
 
         Returns:
-            str: A confirmation message indicating whether join successfully
-                or an error message.
-
-        Raises:
-            SlackApiError: If there is an error during get slack channel
-                information.
+            str: A string containing the API response from Slack.
         """
         from slack_sdk.errors import SlackApiError
 
@@ -148,21 +145,18 @@ class SlackToolkit(BaseToolkit):
             response = slack_client.conversations_join(channel=channel_id)
             return str(response)
         except SlackApiError as e:
-            return f"Error creating conversation: {e.response['error']}"
+            return f"Error joining channel: {e.response['error']}"
 
     def leave_slack_channel(self, channel_id: str) -> str:
-        r"""Leaves an existing Slack channel.
+        r"""Leaves an existing Slack channel. When use this function you must
+        call `get_slack_channel_information` function first to get the
+        `channel id`.
 
         Args:
             channel_id (str): The ID of the Slack channel to leave.
 
         Returns:
-            str: A confirmation message indicating whether leave successfully
-                or an error message.
-
-        Raises:
-            SlackApiError: If there is an error during get slack channel
-                information.
+            str: A string containing the API response from Slack.
         """
         from slack_sdk.errors import SlackApiError
 
@@ -171,18 +165,18 @@ class SlackToolkit(BaseToolkit):
             response = slack_client.conversations_leave(channel=channel_id)
             return str(response)
         except SlackApiError as e:
-            return f"Error creating conversation: {e.response['error']}"
+            return f"Error leaving channel: {e.response['error']}"
 
     def get_slack_channel_information(self) -> str:
-        r"""Retrieve Slack channels and return relevant information in JSON
-            format.
+        r"""Retrieve a list of all public channels in the Slack workspace.
 
-        Returns:
-            str: JSON string containing information about Slack channels.
+        This function is crucial for discovering available channels and their
+        `channel_id`s, which are required by many other functions.
 
-        Raises:
-            SlackApiError: If there is an error during get slack channel
-                information.
+        Returns:
+            str: A JSON string representing a list of channels. Each channel
+                object in the list contains 'id', 'name', 'created', and
+                'num_members'. Returns an error message string on failure.
         """
         from slack_sdk.errors import SlackApiError
 
@@ -204,21 +198,20 @@ class SlackToolkit(BaseToolkit):
             ]
             return json.dumps(filtered_result, ensure_ascii=False)
         except SlackApiError as e:
-            return f"Error creating conversation: {e.response['error']}"
+            return f"Error retrieving channel list: {e.response['error']}"
 
     def get_slack_channel_message(self, channel_id: str) -> str:
-        r"""Retrieve messages from a Slack channel.
+        r"""Retrieve messages from a Slack channel. When use this function you
+        must call `get_slack_channel_information` function first to get the
+        `channel id`.
 
         Args:
             channel_id (str): The ID of the Slack channel to retrieve messages
                 from.
 
         Returns:
-            str: JSON string containing filtered message data.
-
-        Raises:
-            SlackApiError: If there is an error during get
-                slack channel message.
+            str: A JSON string representing a list of messages. Each message
+                object contains 'user', 'text', and 'ts' (timestamp).
         """
         from slack_sdk.errors import SlackApiError
 
@@ -242,19 +235,21 @@ class SlackToolkit(BaseToolkit):
         file_path: Optional[str] = None,
         user: Optional[str] = None,
     ) -> str:
-        r"""Send a message to a Slack channel.
+        r"""Send a message to a Slack channel. When use this function you must
+        call `get_slack_channel_information` function first to get the
+        `channel id`.
 
         Args:
             message (str): The message to send.
-            channel_id (str): The ID of the Slack channel to send message.
-            file_path (Optional[str]): The path of the file to send.
-                Defaults to `None`.
-            user (Optional[str]): The user ID of the recipient.
-                Defaults to `None`.
+            channel_id (str): The ID of the channel to send the message to.
+            file_path (Optional[str]): The local path of a file to upload
+                with the message.
+            user (Optional[str]): The ID of a user to send an ephemeral
+                message to (visible only to that user).
 
         Returns:
-            str: A confirmation message indicating whether the message was sent
-                successfully or an error message.
+            str: A confirmation message indicating success or an error
+                message.
         """
         from slack_sdk.errors import SlackApiError
 
@@ -280,25 +275,25 @@ class SlackToolkit(BaseToolkit):
                 f"got response: {response}"
             )
         except SlackApiError as e:
-            return f"Error creating conversation: {e.response['error']}"
+            return f"Error sending message: {e.response['error']}"
 
     def delete_slack_message(
         self,
         time_stamp: str,
         channel_id: str,
     ) -> str:
-        r"""Delete a message to a Slack channel.
+        r"""Delete a message from a Slack channel. When use this function you
+        must call `get_slack_channel_information` function first to get the
+        `channel id`.
 
         Args:
-            time_stamp (str): Timestamp of the message to be deleted.
-            channel_id (str): The ID of the Slack channel to delete message.
+            time_stamp (str): The 'ts' value of the message to be deleted.
+                You can get this from the `get_slack_channel_message` function.
+            channel_id (str): The ID of the channel where the message is. Use
+                `get_slack_channel_information` to find the `channel_id`.
 
         Returns:
-            str: A confirmation message indicating whether the message
-                was delete successfully or an error message.
-
-        Raises:
-            SlackApiError: If an error occurs while sending the message.
+            str: A string containing the API response from Slack.
         """
         from slack_sdk.errors import SlackApiError
 
@@ -309,7 +304,7 @@ class SlackToolkit(BaseToolkit):
             )
             return str(response)
         except SlackApiError as e:
-            return f"Error creating conversation: {e.response['error']}"
+            return f"Error deleting message: {e.response['error']}"
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the

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.