camel-ai 0.2.70__py3-none-any.whl → 0.2.71a2__py3-none-any.whl

camel/toolkits/terminal_toolkit.py

@@ -81,9 +81,10 @@ class TerminalToolkit(BaseToolkit):
         self.terminal_ready = threading.Event()
         self.gui_thread = None
         self.safe_mode = safe_mode
-
+        self._file_initialized = False
         self.cloned_env_path = None
         self.use_shell_mode = use_shell_mode
+        self._human_takeover_active = False
 
         self.python_executable = sys.executable
         self.is_macos = platform.system() == 'Darwin'
@@ -129,25 +130,20 @@ class TerminalToolkit(BaseToolkit):
 
         self.log_file = os.path.join(os.getcwd(), "camel_terminal.txt")
 
-        if os.path.exists(self.log_file):
-            with open(self.log_file, "w") as f:
-                f.truncate(0)
-                f.write("CAMEL Terminal Session\n")
-                f.write("=" * 50 + "\n")
-                f.write(f"Working Directory: {os.getcwd()}\n")
-                f.write("=" * 50 + "\n\n")
-        else:
-            with open(self.log_file, "w") as f:
-                f.write("CAMEL Terminal Session\n")
-                f.write("=" * 50 + "\n")
-                f.write(f"Working Directory: {os.getcwd()}\n")
-                f.write("=" * 50 + "\n\n")
-
         # Inform the user
-        logger.info(f"Terminal output redirected to: {self.log_file}")
+        logger.info(f"Terminal output will be redirected to: {self.log_file}")
 
         def file_update(output: str):
             try:
+                # Initialize file on first write
+                if not self._file_initialized:
+                    with open(self.log_file, "w") as f:
+                        f.write("CAMEL Terminal Session\n")
+                        f.write("=" * 50 + "\n")
+                        f.write(f"Working Directory: {os.getcwd()}\n")
+                        f.write("=" * 50 + "\n\n")
+                    self._file_initialized = True
+
                 # Directly append to the end of the file
                 with open(self.log_file, "a") as f:
                     f.write(output)
@@ -165,6 +161,12 @@ class TerminalToolkit(BaseToolkit):
     def _clone_current_environment(self):
         r"""Create a new Python virtual environment."""
         try:
+            if self.cloned_env_path is None:
+                self._update_terminal_output(
+                    "Error: No environment path specified\n"
+                )
+                return
+
             if os.path.exists(self.cloned_env_path):
                 self._update_terminal_output(
                     f"Using existing environment: {self.cloned_env_path}\n"
@@ -704,59 +706,35 @@ class TerminalToolkit(BaseToolkit):
                 elif command.startswith('pip'):
                     command = command.replace('pip', pip_path, 1)
 
-            if self.is_macos:
-                # Type safe version - macOS uses subprocess.run
-                process = subprocess.run(
-                    command,
-                    shell=True,
-                    cwd=self.working_dir,
-                    capture_output=True,
-                    text=True,
-                    env=os.environ.copy(),
-                )
-
-                # Process the output
-                output = process.stdout or ""
-                if process.stderr:
-                    output += f"\nStderr Output:\n{process.stderr}"
-
-                # Update session information and terminal
-                self.shell_sessions[id]["output"] = output
-                self._update_terminal_output(output + "\n")
-
-                return output
-
-            else:
-                # Non-macOS systems use the Popen method
-                proc = subprocess.Popen(
-                    command,
-                    shell=True,
-                    cwd=self.working_dir,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    stdin=subprocess.PIPE,
-                    text=True,
-                    bufsize=1,
-                    universal_newlines=True,
-                    env=os.environ.copy(),
-                )
+            proc = subprocess.Popen(
+                command,
+                shell=True,
+                cwd=self.working_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+                env=os.environ.copy(),
+            )
 
-                # Store the process and mark it as running
-                self.shell_sessions[id]["process"] = proc
-                self.shell_sessions[id]["running"] = True
+            # Store the process and mark it as running
+            self.shell_sessions[id]["process"] = proc
+            self.shell_sessions[id]["running"] = True
 
-                # Get output
-                stdout, stderr = proc.communicate()
+            # Get output
+            stdout, stderr = proc.communicate()
 
-                output = stdout or ""
-                if stderr:
-                    output += f"\nStderr Output:\n{stderr}"
+            output = stdout or ""
+            if stderr:
+                output += f"\nStderr Output:\n{stderr}"
 
-                # Update session information and terminal
-                self.shell_sessions[id]["output"] = output
-                self._update_terminal_output(output + "\n")
+            # Update session information and terminal
+            self.shell_sessions[id]["output"] = output
+            self._update_terminal_output(output + "\n")
 
-                return output
+            return output
 
         except Exception as e:
             error_msg = f"Command execution error: {e!s}"
@@ -960,6 +938,169 @@ class TerminalToolkit(BaseToolkit):
             logger.error(f"Error killing process: {e}")
             return f"Error killing process: {e!s}"
 
+    def ask_user_for_help(self, id: str) -> str:
+        r"""Pauses agent execution to ask a human for help in the terminal.
+
+        This function should be called when an agent is stuck or needs
+        assistance with a task that requires manual intervention (e.g.,
+        solving a CAPTCHA or complex debugging). The human will take over the
+        specified terminal session to execute commands and then return control
+        to the agent.
+
+        Args:
+            id (str): Identifier of the shell session for the human to
+                interact with. If the session does not yet exist, it will be
+                created automatically.
+
+        Returns:
+            str: A status message indicating that the human has finished,
+                including the number of commands executed.
+        """
+        # Input validation
+        if not id or not isinstance(id, str):
+            return "Error: Invalid session ID provided"
+
+        # Prevent concurrent human takeovers
+        if (
+            hasattr(self, '_human_takeover_active')
+            and self._human_takeover_active
+        ):
+            return "Error: Human takeover already in progress"
+
+        try:
+            self._human_takeover_active = True
+
+            # Ensure the session exists so that the human can reuse it
+            if id not in self.shell_sessions:
+                self.shell_sessions[id] = {
+                    "process": None,
+                    "output": "",
+                    "running": False,
+                }
+
+            command_count = 0
+            error_occurred = False
+
+            # Create clear banner message for user
+            takeover_banner = (
+                f"\n{'='*60}\n"
+                f"🤖 CAMEL Agent needs human help! Session: {id}\n"
+                f"📂 Working directory: {self.working_dir}\n"
+                f"{'='*60}\n"
+                f"💡 Type commands or '/exit' to return control to agent.\n"
+                f"{'='*60}\n"
+            )
+
+            # Print once to console for immediate visibility
+            print(takeover_banner, flush=True)
+            # Log for terminal output tracking
+            self._update_terminal_output(takeover_banner)
+
+            # Helper flag + event for coordination
+            done_event = threading.Event()
+
+            def _human_loop() -> None:
+                r"""Blocking loop that forwards human input to shell_exec."""
+                nonlocal command_count, error_occurred
+                try:
+                    while True:
+                        try:
+                            # Clear, descriptive prompt for user input
+                            user_cmd = input(f"🧑‍💻 [{id}]> ")
+                            if (
+                                user_cmd.strip()
+                            ):  # Only count non-empty commands
+                                command_count += 1
+                        except EOFError:
+                            # e.g. Ctrl_D / stdin closed, treat as exit.
+                            break
+                        except (KeyboardInterrupt, Exception) as e:
+                            logger.warning(
+                                f"Input error during human takeover: {e}"
+                            )
+                            error_occurred = True
+                            break
+
+                        if user_cmd.strip() in {"/exit", "exit", "quit"}:
+                            break
+
+                        try:
+                            exec_result = self.shell_exec(id, user_cmd)
+                            # Show the result immediately to the user
+                            if exec_result.strip():
+                                print(exec_result)
+                            logger.info(
+                                f"Human command executed: {user_cmd[:50]}..."
+                            )
+                            # Auto-exit after successful command
+                            break
+                        except Exception as e:
+                            error_msg = f"Error executing command: {e}"
+                            logger.error(f"Error executing human command: {e}")
+                            print(error_msg)  # Show error to user immediately
+                            self._update_terminal_output(f"{error_msg}\n")
+                            error_occurred = True
+
+                except Exception as e:
+                    logger.error(f"Unexpected error in human loop: {e}")
+                    error_occurred = True
+                finally:
+                    # Notify completion clearly
+                    finish_msg = (
+                        f"\n{'='*60}\n"
+                        f"✅ Human assistance completed! "
+                        f"Commands: {command_count}\n"
+                        f"🤖 Returning control to CAMEL agent...\n"
+                        f"{'='*60}\n"
+                    )
+                    print(finish_msg, flush=True)
+                    self._update_terminal_output(finish_msg)
+                    done_event.set()
+
+            # Start interactive thread (non-daemon for proper cleanup)
+            thread = threading.Thread(target=_human_loop, daemon=False)
+            thread.start()
+
+            # Block until human signals completion with timeout
+            if done_event.wait(timeout=600):  # 10 minutes timeout
+                thread.join(timeout=10)  # Give thread time to cleanup
+
+                # Generate detailed status message
+                status = "completed successfully"
+                if error_occurred:
+                    status = "completed with some errors"
+
+                result_msg = (
+                    f"Human assistance {status} for session '{id}'. "
+                    f"Total commands executed: {command_count}. "
+                    f"Working directory: {self.working_dir}"
+                )
+                logger.info(result_msg)
+                return result_msg
+            else:
+                timeout_msg = (
+                    f"Human takeover for session '{id}' timed out after 10 "
+                    "minutes"
+                )
+                logger.warning(timeout_msg)
+                return timeout_msg
+
+        except Exception as e:
+            error_msg = f"Error during human takeover for session '{id}': {e}"
+            logger.error(error_msg)
+            # Notify user of the error clearly
+            error_banner = (
+                f"\n{'='*60}\n"
+                f"❌ Error in human takeover! Session: {id}\n"
+                f"❗ {e}\n"
+                f"{'='*60}\n"
+            )
+            print(error_banner, flush=True)
+            return error_msg
+        finally:
+            # Always reset the flag
+            self._human_takeover_active = False
+
     def __del__(self):
         r"""Clean up resources when the object is being destroyed.
         Terminates all running processes and closes any open file handles.
@@ -1041,4 +1182,5 @@ class TerminalToolkit(BaseToolkit):
             FunctionTool(self.shell_wait),
             FunctionTool(self.shell_write_to_process),
             FunctionTool(self.shell_kill_process),
+            FunctionTool(self.ask_user_for_help),
         ]

camel/toolkits/video_download_toolkit.py

@@ -26,7 +26,7 @@ from PIL import Image
 from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
-from camel.utils import MCPServer, dependencies_required
+from camel.utils import dependencies_required
 
 logger = get_logger(__name__)
 
@@ -57,7 +57,6 @@ def _capture_screenshot(video_file: str, timestamp: float) -> Image.Image:
     return Image.open(io.BytesIO(out))
 
 
-@MCPServer()
 class VideoDownloaderToolkit(BaseToolkit):
     r"""A class for downloading videos and optionally splitting them into
     chunks.
@@ -123,6 +122,9 @@ class VideoDownloaderToolkit(BaseToolkit):
         yt-dlp will detect if the video is downloaded automatically so there
         is no need to check if the video exists.
 
+        Args:
+            url (str): The URL of the video to download.
+
         Returns:
             str: The path to the downloaded video file.
         """
@@ -175,7 +177,8 @@ class VideoDownloaderToolkit(BaseToolkit):
         dividing the video into equal parts if an integer is provided.
 
         Args:
-            video_url (str): The URL of the video to take screenshots.
+            video_path (str): The local path or URL of the video to take
+              screenshots.
             amount (int): the amount of evenly split screenshots to capture.
 
         Returns:

camel/utils/message_summarizer.py

@@ -0,0 +1,148 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend, ModelFactory
+from camel.types import ModelPlatformType, ModelType
+
+
+class MessageSummary(BaseModel):
+    r"""Schema for structured message summaries.
+
+    Attributes:
+        summary (str): A brief, one-sentence summary of the conversation.
+        participants (List[str]): The roles of participants involved.
+        key_topics_and_entities (List[str]): Important topics, concepts, and
+            entities discussed.
+        decisions_and_outcomes (List[str]): Key decisions, conclusions, or
+            outcomes reached.
+        action_items (List[str]): A list of specific tasks or actions to be
+            taken, with assignees if mentioned.
+        progress_on_main_task (str): A summary of progress made on the
+            primary task.
+    """
+
+    summary: str = Field(
+        description="A brief, one-sentence summary of the conversation."
+    )
+    participants: List[str] = Field(
+        description="The roles of participants involved."
+    )
+    key_topics_and_entities: List[str] = Field(
+        description="Important topics, concepts, and entities discussed."
+    )
+    decisions_and_outcomes: List[str] = Field(
+        description="Key decisions, conclusions, or outcomes reached."
+    )
+    action_items: List[str] = Field(
+        description=(
+            "A list of specific tasks or actions to be taken, with assignees "
+            "if mentioned."
+        )
+    )
+    progress_on_main_task: str = Field(
+        description="A summary of progress made on the primary task."
+    )
+
+
+class MessageSummarizer:
+    r"""Utility class for generating structured summaries of chat messages.
+
+    Args:
+        model_backend (Optional[BaseModelBackend], optional):
+            The model backend to use for summarization.
+            If not provided, a default model backend will be created.
+    """
+
+    def __init__(
+        self,
+        model_backend: Optional[BaseModelBackend] = None,
+    ):
+        if model_backend is None:
+            self.model_backend = ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.GPT_4O_MINI,
+            )
+        else:
+            self.model_backend = model_backend
+        self.agent = ChatAgent(
+            BaseMessage.make_assistant_message(
+                role_name="Message Summarizer",
+                content=(
+                    "You are an expert conversation summarizer. Your task is "
+                    "to analyze chat messages and create a structured summary "
+                    "in JSON format. The summary should capture:\n"
+                    "- summary: A brief, one-sentence summary of the "
+                    "conversation.\n"
+                    "- participants: The roles of participants involved.\n"
+                    "- key_topics_and_entities: Important topics, concepts, "
+                    "and entities discussed.\n"
+                    "- decisions_and_outcomes: Key decisions, conclusions, or "
+                    "outcomes reached.\n"
+                    "- action_items: A list of specific tasks or actions to "
+                    "be taken, with assignees if mentioned.\n"
+                    "- progress_on_main_task: A summary of progress made on "
+                    "the primary task.\n\n"
+                    "Your response must be a JSON object that strictly "
+                    "adheres to this structure. Be concise and accurate."
+                ),
+            ),
+            model=self.model_backend,
+        )
+
+    def summarize(self, messages: List[BaseMessage]) -> MessageSummary:
+        r"""Generate a structured summary of the provided messages.
+
+        Args:
+            messages (List[BaseMessage]): List of messages to summarize.
+
+        Returns:
+            MessageSummary: Structured summary of the conversation.
+
+        Raises:
+            ValueError: If the messages list is empty or if the model's
+            response cannot be parsed as valid JSON.
+        """
+        if not messages:
+            raise ValueError("Cannot summarize an empty list of messages.")
+
+        # Construct prompt from messages
+        message_text = "\n".join(
+            f"{msg.role_name}: {msg.content}" for msg in messages
+        )
+        prompt = (
+            "Please analyze the following chat messages and generate a "
+            "structured summary.\n\n"
+            f"MESSAGES:\n\"\"\"\n{message_text}\n\"\"\"\n\n"
+            "Your response must be a JSON object that strictly adheres to the "
+            "required format."
+        )
+
+        # Get structured summary from model with forced JSON response
+        response = self.agent.step(prompt, response_format=MessageSummary)
+
+        if response.msg is None or response.msg.parsed is None:
+            raise ValueError(
+                "Failed to get a structured summary from the model."
+            )
+
+        summary = response.msg.parsed
+        if not isinstance(summary, MessageSummary):
+            raise ValueError("The parsed response is not a MessageSummary.")
+
+        return summary

{camel_ai-0.2.70.dist-info → camel_ai-0.2.71a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.70
+Version: 0.2.71a2
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -54,7 +54,6 @@ Requires-Dist: ffmpeg-python<0.3,>=0.2.0; extra == 'all'
 Requires-Dist: firecrawl-py<2,>=1.0.0; extra == 'all'
 Requires-Dist: fish-audio-sdk<2025,>=2024.12.5; extra == 'all'
 Requires-Dist: flask>=2.0; extra == 'all'
-Requires-Dist: fpdf>=1.7.2; extra == 'all'
 Requires-Dist: google-api-python-client==2.166.0; extra == 'all'
 Requires-Dist: google-auth-httplib2==0.2.0; extra == 'all'
 Requires-Dist: google-auth-oauthlib==1.2.1; extra == 'all'
@@ -99,6 +98,7 @@ Requires-Dist: pygithub<3,>=2.6.0; extra == 'all'
 Requires-Dist: pylatex>=1.4.2; extra == 'all'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'all'
 Requires-Dist: pymupdf<2,>=1.22.5; extra == 'all'
+Requires-Dist: pymupdf>=1.26.1; extra == 'all'
 Requires-Dist: pyobvector>=0.1.18; extra == 'all'
 Requires-Dist: pyowm<4,>=3.3.0; extra == 'all'
 Requires-Dist: pytelegrambotapi<5,>=4.18.0; extra == 'all'
@@ -206,7 +206,6 @@ Requires-Dist: chunkr-ai>=0.0.50; extra == 'document-tools'
 Requires-Dist: crawl4ai>=0.3.745; extra == 'document-tools'
 Requires-Dist: docx2txt<0.9,>=0.8; extra == 'document-tools'
 Requires-Dist: docx>=0.2.4; extra == 'document-tools'
-Requires-Dist: fpdf>=1.7.2; extra == 'document-tools'
 Requires-Dist: markitdown==0.1.1; extra == 'document-tools'
 Requires-Dist: numpy<=2.2,>=1.2; extra == 'document-tools'
 Requires-Dist: openapi-spec-validator<0.8,>=0.7.1; extra == 'document-tools'
@@ -215,6 +214,7 @@ Requires-Dist: pandasai<3,>=2.3.0; extra == 'document-tools'
 Requires-Dist: prance<24,>=23.6.21.0; extra == 'document-tools'
 Requires-Dist: pylatex>=1.4.2; extra == 'document-tools'
 Requires-Dist: pymupdf<2,>=1.22.5; extra == 'document-tools'
+Requires-Dist: pymupdf>=1.26.1; extra == 'document-tools'
 Requires-Dist: python-pptx>=1.0.2; extra == 'document-tools'
 Requires-Dist: tabulate>=0.9.0; extra == 'document-tools'
 Requires-Dist: unstructured==0.16.20; extra == 'document-tools'
@@ -254,7 +254,6 @@ Requires-Dist: docx>=0.2.4; extra == 'owl'
 Requires-Dist: duckduckgo-search<7,>=6.3.5; extra == 'owl'
 Requires-Dist: e2b-code-interpreter<2,>=1.0.3; extra == 'owl'
 Requires-Dist: ffmpeg-python<0.3,>=0.2.0; extra == 'owl'
-Requires-Dist: fpdf>=1.7.2; extra == 'owl'
 Requires-Dist: html2text>=2024.2.26; extra == 'owl'
 Requires-Dist: imageio[pyav]<3,>=2.34.2; extra == 'owl'
 Requires-Dist: markitdown==0.1.1; extra == 'owl'
@@ -272,6 +271,7 @@ Requires-Dist: pyautogui<0.10,>=0.9.54; extra == 'owl'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'owl'
 Requires-Dist: pylatex>=1.4.2; extra == 'owl'
 Requires-Dist: pymupdf<2,>=1.22.5; extra == 'owl'
+Requires-Dist: pymupdf>=1.26.1; extra == 'owl'
 Requires-Dist: pytesseract>=0.3.13; extra == 'owl'
 Requires-Dist: python-dotenv<2,>=1.0.0; extra == 'owl'
 Requires-Dist: python-pptx>=1.0.2; extra == 'owl'