camel-ai 0.2.72a1__tar.gz → 0.2.72a4__tar.gz

{camel_ai-0.2.72a1 → camel_ai-0.2.72a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.72a1
+Version: 0.2.72a4
 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.72a1 → camel_ai-0.2.72a4}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.72a1'
+__version__ = '0.2.72a4'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.72a1 → camel_ai-0.2.72a4}/camel/societies/workforce/prompts.py

@@ -202,16 +202,20 @@ TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks a
     *   **DO NOT** use relative references like "the first task," "the paper mentioned above," or "the result from the previous step."
     *   **DO** write explicit instructions. For example, instead of "Analyze the document," write "Analyze the document titled 'The Future of AI'." The system will automatically provide the necessary inputs (like the document itself) from previous steps.
 
-1.  **Strategic Grouping for Sequential Work**:
+2.  **Define Clear Deliverables**: Each subtask must specify a clear, concrete deliverable. This tells the agent exactly what to produce and provides a clear "definition of done."
+    *   **DO NOT** use vague verbs like "analyze," "look into," or "research" without defining the output.
+    *   **DO** specify the format and content of the output. For example, instead of "Analyze the attached report," write "Summarize the key findings of the attached report in a 3-bullet-point list." Instead of "Find contacts," write "Extract all names and email addresses from the document and return them as a JSON list of objects, where each object has a 'name' and 'email' key."
+
+3.  **Strategic Grouping for Sequential Work**:
     *   If a series of steps must be done in order *and* can be handled by the same worker type, group them into a single subtask to maintain flow and minimize handoffs.
 
-2.  **Aggressive Parallelization**:
+4.  **Aggressive Parallelization**:
     *   **Across Different Worker Specializations**: If distinct phases of the overall task require different types of workers (e.g., research by a 'SearchAgent', then content creation by a 'DocumentAgent'), define these as separate subtasks.
     *   **Within a Single Phase (Data/Task Parallelism)**: If a phase involves repetitive operations on multiple items (e.g., processing 10 documents, fetching 5 web pages, analyzing 3 datasets):
         *   Decompose this into parallel subtasks, one for each item or a small batch of items.
         *   This applies even if the same type of worker handles these parallel subtasks. The goal is to leverage multiple available workers or allow concurrent processing.
 
-3.  **Subtask Design for Efficiency**:
+5.  **Subtask Design for Efficiency**:
     *   **Actionable and Well-Defined**: Each subtask should have a clear, achievable goal.
     *   **Balanced Granularity**: Make subtasks large enough to be meaningful but small enough to enable parallelism and quick feedback. Avoid overly large subtasks that hide parallel opportunities.
     *   **Consider Dependencies**: While you list tasks sequentially, think about the true dependencies. The workforce manager will handle execution based on these implied dependencies and worker availability.
@@ -229,10 +233,10 @@ These principles aim to reduce overall completion time by maximizing concurrent
 *   **Correct Decomposition**:
     ```xml
     <tasks>
-    <task>Create a short blog post about the benefits of Python by researching key benefits, writing a 300-word article, and finding a suitable image.</task>
+    <task>Create a short blog post about the benefits of Python by researching key benefits, writing a 300-word article, and finding a suitable image. The final output should be a single string containing the 300-word article followed by the image URL.</task>
     </tasks>
     ```
-*   **Reasoning**: All steps are sequential and can be handled by the same worker type (`Document Agent`). Grouping them into one subtask is efficient and maintains the workflow, following the "Strategic Grouping" principle.
+*   **Reasoning**: All steps are sequential and can be handled by the same worker type (`Document Agent`). Grouping them into one subtask is efficient and maintains the workflow, following the "Strategic Grouping" principle. **The deliverable is clearly defined as a single string.**
 
 ***
 **Example 2: Parallel Task Across Different Workers**
@@ -245,14 +249,14 @@ These principles aim to reduce overall completion time by maximizing concurrent
 *   **Correct Decomposition**:
     ```xml
     <tasks>
-    <task>Create a financial summary for Apple (AAPL) for Q2.</task>
-    <task>Create a financial summary for Google (GOOGL) for Q2.</task>
-    <task>Perform market sentiment analysis for Apple (AAPL) for Q2.</task>
-    <task>Perform market sentiment analysis for Google (GOOGL) for Q2.</task>
-    <task>Compile the provided financial summaries and market sentiment analyses for Apple (AAPL) and Google (GOOGL) into a single Q2 performance report.</task>
+    <task>Create a 1-paragraph financial summary for Apple (AAPL) for Q2, covering revenue, net income, and EPS. The output must be a plain text paragraph.</task>
+    <task>Create a 1-paragraph financial summary for Google (GOOGL) for Q2, covering revenue, net income, and EPS. The output must be a plain text paragraph.</task>
+    <task>Perform a market sentiment analysis for Apple (AAPL) for Q2, returning a single sentiment score from -1 (very negative) to 1 (very positive). The output must be a single floating-point number.</task>
+    <task>Perform a market sentiment analysis for Google (GOOGL) for Q2, returning a single sentiment score from -1 (very negative) to 1 (very positive). The output must be a single floating-point number.</task>
+    <task>Compile the provided financial summaries and market sentiment scores for Apple (AAPL) and Google (GOOGL) into a single Q2 performance report. The report should be a markdown-formatted document.</task>
     </tasks>
     ```
-*   **Reasoning**: The financial analysis and market research can be done in parallel for both companies. The final report depends on all previous steps. This decomposition leverages worker specialization and parallelism, following the "Aggressive Parallelization" principle.
+*   **Reasoning**: The financial analysis and market research can be done in parallel for both companies. The final report depends on all previous steps. This decomposition leverages worker specialization and parallelism, following the "Aggressive Parallelization" principle. **Each subtask has a clearly defined deliverable.**
 ***
 
 **END OF EXAMPLES** - Now, apply these principles and examples to decompose the following task.

{camel_ai-0.2.72a1 → camel_ai-0.2.72a4}/camel/toolkits/terminal_toolkit.py

@@ -16,6 +16,7 @@ import atexit
 import os
 import platform
 import queue
+import shutil
 import subprocess
 import sys
 import threading
@@ -41,21 +42,25 @@ class TerminalToolkit(BaseToolkit):
 
     Args:
         timeout (Optional[float]): The timeout for terminal operations.
+            (default: :obj:`None`)
         shell_sessions (Optional[Dict[str, Any]]): A dictionary to store
-            shell session information. If None, an empty dictionary will be
-            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"`)
+            shell session information. If :obj:`None`, an empty dictionary
+            will be used. (default: :obj:`None`)
+        working_directory (Optional[str]): The working directory for
+            operations. If not provided, it will be determined by the
+            `CAMEL_WORKDIR` environment variable (if set). If the
+            environment variable is not set, it defaults to `./workspace`. All
+            execution and write operations will be restricted to this
+            directory. Read operations can access paths outside this
+            directory. (default: :obj:`None`)
         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`)
+        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`)
+            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).
@@ -67,7 +72,7 @@ class TerminalToolkit(BaseToolkit):
         self,
         timeout: Optional[float] = None,
         shell_sessions: Optional[Dict[str, Any]] = None,
-        working_dir: str = "./workspace",
+        working_directory: Optional[str] = None,
         need_terminal: bool = True,
         use_shell_mode: bool = True,
         clone_current_env: bool = False,
@@ -88,12 +93,22 @@ class TerminalToolkit(BaseToolkit):
 
         self.python_executable = sys.executable
         self.is_macos = platform.system() == 'Darwin'
+        self.initial_env_path: Optional[str] = None
+        self.initial_env_prepared = False
 
         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)
+        if working_directory:
+            self.working_dir = os.path.abspath(working_directory)
+        else:
+            camel_workdir = os.environ.get("CAMEL_WORKDIR")
+            if camel_workdir:
+                self.working_dir = os.path.abspath(camel_workdir)
+            else:
+                self.working_dir = os.path.abspath("./workspace")
+
+        if not os.path.exists(self.working_dir):
+            os.makedirs(self.working_dir, exist_ok=True)
         self._update_terminal_output(
             f"Working directory set to: {self.working_dir}\n"
         )
@@ -108,6 +123,7 @@ class TerminalToolkit(BaseToolkit):
             self._clone_current_environment()
         else:
             self.cloned_env_path = None
+            self._prepare_initial_environment()
 
         if need_terminal:
             if self.is_macos:
@@ -178,20 +194,243 @@ class TerminalToolkit(BaseToolkit):
                 return
 
             self._update_terminal_output(
-                f"Creating new Python environment at:{self.cloned_env_path}\n"
+                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)
+
+            # 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 at {python_path}\n"
+                )
+
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.decode() if e.stderr else str(e)
             self._update_terminal_output(
-                "New Python environment created successfully!\n"
+                f"Failed to upgrade pip in cloned environment: {error_msg}\n"
+            )
+            logger.error(f"Failed to upgrade pip: {error_msg}")
+        except subprocess.TimeoutExpired:
+            self._update_terminal_output(
+                "Pip upgrade timed out, but environment may still be usable\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 _is_uv_environment(self) -> bool:
+        r"""Detect whether the current Python runtime is managed by uv."""
+        return (
+            "UV_CACHE_DIR" in os.environ
+            or "uv" in sys.executable
+            or shutil.which("uv") is not None
+        )
+
+    def _prepare_initial_environment(self):
+        r"""Prepare initial environment with Python 3.10, pip, and other
+        essential tools.
+        """
+        try:
+            self.initial_env_path = os.path.join(
+                self.working_dir, ".initial_env"
+            )
+
+            if os.path.exists(self.initial_env_path):
+                self._update_terminal_output(
+                    f"Using existing initial environment"
+                    f": {self.initial_env_path}\n"
+                )
+                self.initial_env_prepared = True
+                return
+
+            self._update_terminal_output(
+                f"Preparing initial environment at: {self.initial_env_path}\n"
+            )
+
+            # 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():
+                self._setup_initial_env_with_uv()
+            else:
+                self._setup_initial_env_with_venv()
+
+            self.initial_env_prepared = True
+            self._update_terminal_output(
+                "Initial environment prepared successfully!\n"
+            )
+
+        except Exception as e:
+            self._update_terminal_output(
+                f"Failed to prepare initial environment: {e!s}\n"
+            )
+            logger.error(f"Failed to prepare initial environment: {e}")
+
+    def _setup_initial_env_with_uv(self):
+        r"""Set up initial environment using uv."""
+        if self.initial_env_path is None:
+            raise Exception("Initial environment path not set")
+
+        try:
+            # Create virtual environment with Python 3.10 using uv
+            subprocess.run(
+                ["uv", "venv", "--python", "3.10", self.initial_env_path],
+                check=True,
+                capture_output=True,
+                cwd=self.working_dir,
+                timeout=300,
+            )
+
+            # Get the python path from the new environment
+            if self.os_type == 'Windows':
+                python_path = os.path.join(
+                    self.initial_env_path, "Scripts", "python.exe"
+                )
+            else:
+                python_path = os.path.join(
+                    self.initial_env_path, "bin", "python"
+                )
+
+            # Install essential packages using uv
+            essential_packages = ["pip", "setuptools", "wheel"]
+            subprocess.run(
+                [
+                    "uv",
+                    "pip",
+                    "install",
+                    "--python",
+                    python_path,
+                    *essential_packages,
+                ],
+                check=True,
+                capture_output=True,
+                cwd=self.working_dir,
+                timeout=300,
+            )
+
+            # Check if Node.js is available (but don't install it)
+            self._check_nodejs_availability()
+
+            self._update_terminal_output(
+                "[UV] Initial environment created with Python 3.10 "
+                "and essential packages\n"
+            )
+
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            raise Exception(f"UV setup failed: {error_msg}")
+        except subprocess.TimeoutExpired:
+            raise Exception("UV setup timed out after 5 minutes")
+
+    def _setup_initial_env_with_venv(self):
+        r"""Set up initial environment using standard venv."""
+        if self.initial_env_path is None:
+            raise Exception("Initial environment path not set")
+
+        try:
+            # Create virtual environment with system Python
+            venv.create(
+                self.initial_env_path,
+                with_pip=True,
+                system_site_packages=False,
+            )
+
+            # Get pip path
+            if self.os_type == 'Windows':
+                pip_path = os.path.join(
+                    self.initial_env_path, "Scripts", "pip.exe"
+                )
+            else:
+                pip_path = os.path.join(self.initial_env_path, "bin", "pip")
+
+            # Upgrade pip and install essential packages
+            essential_packages = ["pip", "setuptools", "wheel"]
+            subprocess.run(
+                [pip_path, "install", "--upgrade", *essential_packages],
+                check=True,
+                capture_output=True,
+                cwd=self.working_dir,
+                timeout=300,
+            )
+
+            # Check if Node.js is available (but don't install it)
+            self._check_nodejs_availability()
+
+            self._update_terminal_output(
+                "Initial environment created with system Python and "
+                "essential packages\n"
+            )
+
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            raise Exception(f"Venv setup failed: {error_msg}")
+        except subprocess.TimeoutExpired:
+            raise Exception("Venv setup timed out after 5 minutes")
+
+    def _check_nodejs_availability(self):
+        r"""Check if Node.js is available without modifying the system."""
+        try:
+            # Check if Node.js is already available in the system
+            node_result = subprocess.run(
+                ["node", "--version"],
+                check=False,
+                capture_output=True,
+                timeout=10,
+            )
+
+            npm_result = subprocess.run(
+                ["npm", "--version"],
+                check=False,
+                capture_output=True,
+                timeout=10,
+            )
+
+            if node_result.returncode == 0 and npm_result.returncode == 0:
+                node_version = node_result.stdout.decode().strip()
+                npm_version = npm_result.stdout.decode().strip()
+                self._update_terminal_output(
+                    f"Node.js {node_version} and npm {npm_version} "
+                    "are available\n"
+                )
+            else:
+                self._update_terminal_output(
+                    "Note: Node.js not found. If needed, please install it "
+                    "manually.\n"
+                )
+
+        except Exception as e:
+            self._update_terminal_output(
+                f"Note: Could not check Node.js availability - {e}.\n"
+            )
+            logger.warning(f"Failed to check Node.js: {e}")
+
     def _create_terminal(self):
         r"""Create a terminal GUI. If GUI creation fails, fallback
         to file output."""
@@ -335,108 +574,6 @@ class TerminalToolkit(BaseToolkit):
             logger.error(f"Failed to copy file: {e}")
             return None
 
-    def file_find_in_content(
-        self, file: str, regex: str, sudo: bool = False
-    ) -> str:
-        r"""Search for text within a file's content using a regular expression.
-
-        This function is useful for finding specific patterns or lines of text
-        within a given file. It uses `grep` on Unix-like systems and `findstr`
-        on Windows.
-
-        Args:
-            file (str): The absolute path of the file to search within.
-            regex (str): The regular expression pattern to match.
-            sudo (bool, optional): Whether to use sudo privileges for the
-                search. Defaults to False. Note: Using sudo requires the
-                process to have appropriate permissions.
-                (default: :obj:`False`)
-
-        Returns:
-            str: The matching content found in the file. If no matches are
-                found, an empty string is returned. Returns an error message
-                if the file does not exist or another error occurs.
-        """
-
-        if not os.path.exists(file):
-            return f"File not found: {file}"
-
-        if not os.path.isfile(file):
-            return f"The path provided is not a file: {file}"
-
-        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
-            command.extend(["grep", "-E", regex, file])
-        else:  # Windows
-            # For Windows, we could use PowerShell or findstr
-            command.extend(["findstr", "/R", regex, file])
-
-        try:
-            result = subprocess.run(
-                command, check=False, capture_output=True, text=True
-            )
-            return result.stdout.strip()
-        except subprocess.SubprocessError as e:
-            logger.error(f"Error searching in file content: {e}")
-            return f"Error: {e!s}"
-
-    def file_find_by_name(self, path: str, glob: str) -> str:
-        r"""Find files by name in a specified directory using a glob pattern.
-
-        This function recursively searches for files matching a given name or
-        pattern within a directory. It uses `find` on Unix-like systems and
-        `dir` on Windows.
-
-        Args:
-            path (str): The absolute path of the directory to search in.
-            glob (str): The filename pattern to search for, using glob syntax
-                (e.g., "*.py", "data*").
-
-        Returns:
-            str: A newline-separated string containing the paths of the files
-                that match the pattern. Returns an error message if the
-                directory does not exist or another error occurs.
-        """
-        if not os.path.exists(path):
-            return f"Directory not found: {path}"
-
-        if not os.path.isdir(path):
-            return f"The path provided is not a directory: {path}"
-
-        command = []
-        if self.os_type in ['Darwin', 'Linux']:  # macOS or Linux
-            command.extend(["find", path, "-name", glob])
-        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,
-                shell=False,
-            )
-
-            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 _sanitize_command(self, command: str, exec_dir: str) -> Tuple:
         r"""Check and modify command to ensure safety.
 
@@ -721,24 +858,75 @@ class TerminalToolkit(BaseToolkit):
             self._update_terminal_output(f"\n$ {command}\n")
 
             if command.startswith('python') or command.startswith('pip'):
-                if self.cloned_env_path:
+                python_path = None
+                pip_path = None
+
+                # Try cloned environment first
+                if self.cloned_env_path and os.path.exists(
+                    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")
+                        python_candidate = os.path.join(
+                            base_path, "python.exe"
+                        )
+                        pip_candidate = 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_candidate = os.path.join(base_path, "python")
+                        pip_candidate = os.path.join(base_path, "pip")
+
+                    # Verify the executables exist
+                    if os.path.exists(python_candidate):
+                        python_path = python_candidate
+                        # For pip, use python -m pip if pip executable doesn't
+                        # exist
+                        if os.path.exists(pip_candidate):
+                            pip_path = pip_candidate
+                        else:
+                            pip_path = f'"{python_path}" -m pip'
+
+                # Try initial environment if cloned environment failed
+                if (
+                    python_path is None
+                    and self.initial_env_prepared
+                    and self.initial_env_path
+                    and os.path.exists(self.initial_env_path)
+                ):
+                    if self.os_type == 'Windows':
+                        base_path = os.path.join(
+                            self.initial_env_path, "Scripts"
+                        )
+                        python_candidate = os.path.join(
+                            base_path, "python.exe"
+                        )
+                        pip_candidate = os.path.join(base_path, "pip.exe")
+                    else:
+                        base_path = os.path.join(self.initial_env_path, "bin")
+                        python_candidate = os.path.join(base_path, "python")
+                        pip_candidate = os.path.join(base_path, "pip")
+
+                    # Verify the executables exist
+                    if os.path.exists(python_candidate):
+                        python_path = python_candidate
+                        # For pip, use python -m pip if pip executable doesn't
+                        # exist
+                        if os.path.exists(pip_candidate):
+                            pip_path = pip_candidate
+                        else:
+                            pip_path = f'"{python_path}" -m pip'
+
+                # Fall back to system Python
+                if python_path is None:
                     python_path = self.python_executable
                     pip_path = f'"{python_path}" -m pip'
 
-                if command.startswith('python'):
+                # Ensure we have valid paths before replacement
+                if python_path and command.startswith('python'):
                     command = command.replace('python', f'"{python_path}"', 1)
-                elif command.startswith('pip'):
+                elif pip_path and command.startswith('pip'):
                     command = command.replace('pip', pip_path, 1)
 
             if not interactive:
@@ -1298,13 +1486,25 @@ class TerminalToolkit(BaseToolkit):
                         f"'{session_id}': {e}"
                     )
 
-        # Close file output if it exists
+        # Clean up 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 initial environment if it exists
+        if hasattr(self, 'initial_env_path') and self.initial_env_path:
+            try:
+                if os.path.exists(self.initial_env_path):
+                    shutil.rmtree(self.initial_env_path)
+                    logger.info(
+                        f"Cleaned up initial environment: "
+                        f"{self.initial_env_path}"
+                    )
+            except Exception as e:
+                logger.error(f"Error cleaning up initial environment: {e}")
+
         # Clean up GUI resources if they exist
         if hasattr(self, 'root') and self.root:
             try:
@@ -1325,8 +1525,6 @@ class TerminalToolkit(BaseToolkit):
                 functions in the toolkit.
         """
         return [
-            FunctionTool(self.file_find_in_content),
-            FunctionTool(self.file_find_by_name),
             FunctionTool(self.shell_exec),
             FunctionTool(self.shell_view),
             FunctionTool(self.shell_wait),

{camel_ai-0.2.72a1 → camel_ai-0.2.72a4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "camel-ai"
-version = "0.2.72a1"
+version = "0.2.72a4"
 description = "Communicative Agents for AI Society Study"
 authors = [{ name = "CAMEL-AI.org" }]
 requires-python = ">=3.10,<3.13"