camel-ai 0.2.72a0__tar.gz → 0.2.72a2__tar.gz

{camel_ai-0.2.72a0 → camel_ai-0.2.72a2}/PKG-INFO

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

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

{camel_ai-0.2.72a0 → camel_ai-0.2.72a2}/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.72a0 → camel_ai-0.2.72a2}/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 = 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:
@@ -192,6 +208,187 @@ class TerminalToolkit(BaseToolkit):
             )
             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."""
+        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."""
+        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."""
@@ -722,6 +919,7 @@ class TerminalToolkit(BaseToolkit):
 
             if command.startswith('python') or command.startswith('pip'):
                 if self.cloned_env_path:
+                    # Use cloned environment
                     if self.os_type == 'Windows':
                         base_path = os.path.join(
                             self.cloned_env_path, "Scripts"
@@ -732,7 +930,20 @@ class TerminalToolkit(BaseToolkit):
                         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")
+                elif self.initial_env_prepared and self.initial_env_path:
+                    # Use initial prepared environment
+                    if self.os_type == 'Windows':
+                        base_path = os.path.join(
+                            self.initial_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.initial_env_path, "bin")
+                        python_path = os.path.join(base_path, "python")
+                        pip_path = os.path.join(base_path, "pip")
                 else:
+                    # Fall back to system Python
                     python_path = self.python_executable
                     pip_path = f'"{python_path}" -m pip'
 
@@ -1298,13 +1509,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:

{camel_ai-0.2.72a0 → camel_ai-0.2.72a2}/pyproject.toml

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