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

camel/toolkits/craw4ai_toolkit.py

@@ -31,6 +31,16 @@ class Crawl4AIToolkit(BaseToolkit):
         timeout: Optional[float] = None,
     ):
         super().__init__(timeout=timeout)
+        self._client = None
+
+    async def _get_client(self):
+        r"""Get or create the AsyncWebCrawler client."""
+        if self._client is None:
+            from crawl4ai import AsyncWebCrawler
+
+            self._client = AsyncWebCrawler()
+            await self._client.__aenter__()
+        return self._client
 
     async def scrape(self, url: str) -> str:
         r"""Scrapes a webpage and returns its content.
@@ -47,19 +57,29 @@ class Crawl4AIToolkit(BaseToolkit):
             str: The scraped content of the webpage as a string. If the
                 scraping fails, it will return an error message.
         """
-        from crawl4ai import AsyncWebCrawler, CrawlerRunConfig
+        from crawl4ai import CrawlerRunConfig
 
         try:
-            async with AsyncWebCrawler() as client:
-                config = CrawlerRunConfig(
-                    only_text=True,
-                )
-                content = await client.arun(url, crawler_config=config)
-                return str(content.markdown) if content.markdown else ""
+            client = await self._get_client()
+            config = CrawlerRunConfig(
+                only_text=True,
+            )
+            content = await client.arun(url, crawler_config=config)
+            return str(content.markdown) if content.markdown else ""
         except Exception as e:
             logger.error(f"Error scraping {url}: {e}")
             return f"Error scraping {url}: {e}"
 
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit - cleanup the client."""
+        if self._client is not None:
+            await self._client.__aexit__(exc_type, exc_val, exc_tb)
+            self._client = None
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
         functions in the toolkit.

camel/toolkits/file_write_toolkit.py

@@ -146,23 +146,25 @@ class FileWriteToolkit(BaseToolkit):
         document.save(str(file_path))
         logger.debug(f"Wrote DOCX to {file_path} with default formatting")
 
-    @dependencies_required('pylatex', 'fpdf')
+    @dependencies_required('pylatex', 'pymupdf')
     def _write_pdf_file(
-        self, file_path: Path, content: str, use_latex: bool = False
+        self,
+        file_path: Path,
+        title: str,
+        content: str,
+        use_latex: bool = False,
     ) -> None:
         r"""Write text content to a PDF file with default formatting.
 
         Args:
             file_path (Path): The target file path.
+            title (str): The title of the document.
             content (str): The text content to write.
             use_latex (bool): Whether to use LaTeX for rendering. (requires
-                LaTeX toolchain). If False, uses FPDF for simpler PDF
+                LaTeX toolchain). If False, uses PyMuPDF for simpler PDF
                 generation. (default: :obj:`False`)
-
-        Raises:
-            RuntimeError: If the 'pylatex' or 'fpdf' library is not installed
-                when use_latex=True.
         """
+        # TODO: table generation need to be improved
         if use_latex:
             from pylatex import (
                 Command,
@@ -213,30 +215,105 @@ class FileWriteToolkit(BaseToolkit):
 
             logger.info(f"Wrote PDF (with LaTeX) to {file_path}")
         else:
-            from fpdf import FPDF
-
-            # Use default formatting values
-            font_family = 'Arial'
-            font_size = 12
-            font_style = ''
-            line_height = 10
-            margin = 10
-
-            pdf = FPDF()
-            pdf.set_margins(margin, margin, margin)
-
-            pdf.add_page()
-            pdf.set_font(font_family, style=font_style, size=font_size)
-
-            # Split content into paragraphs and add them
-            for para in content.split('\n'):
-                if para.strip():  # Skip empty paragraphs
-                    pdf.multi_cell(0, line_height, para)
+            import pymupdf
+
+            # Create a new PDF document
+            doc = pymupdf.open()
+
+            # Add a page
+            page = doc.new_page()
+
+            # Process the content
+            lines = content.strip().split('\n')
+            document_title = title
+
+            # Create a TextWriter for writing text to the page
+            text_writer = pymupdf.TextWriter(page.rect)
+
+            # Define fonts
+            normal_font = pymupdf.Font(
+                "helv"
+            )  # Standard font with multilingual support
+            bold_font = pymupdf.Font("helv")
+
+            # Start position for text
+            y_pos = 50
+            x_pos = 50
+
+            # Add title
+            text_writer.fill_textbox(
+                pymupdf.Rect(
+                    x_pos, y_pos, page.rect.width - x_pos, y_pos + 30
+                ),
+                document_title,
+                fontsize=16,
+            )
+            y_pos += 40
+
+            # Process content
+            for line in lines:
+                stripped_line = line.strip()
+
+                # Skip empty lines but add some space
+                if not stripped_line:
+                    y_pos += 10
+                    continue
+
+                # Handle headers
+                if stripped_line.startswith('## '):
+                    text_writer.fill_textbox(
+                        pymupdf.Rect(
+                            x_pos, y_pos, page.rect.width - x_pos, y_pos + 20
+                        ),
+                        stripped_line[3:].strip(),
+                        font=bold_font,
+                        fontsize=14,
+                    )
+                    y_pos += 25
+                elif stripped_line.startswith('# '):
+                    text_writer.fill_textbox(
+                        pymupdf.Rect(
+                            x_pos, y_pos, page.rect.width - x_pos, y_pos + 25
+                        ),
+                        stripped_line[2:].strip(),
+                        font=bold_font,
+                        fontsize=16,
+                    )
+                    y_pos += 30
+                # Handle horizontal rule
+                elif stripped_line == '---':
+                    page.draw_line(
+                        pymupdf.Point(x_pos, y_pos + 5),
+                        pymupdf.Point(page.rect.width - x_pos, y_pos + 5),
+                    )
+                    y_pos += 15
+                # Regular text
                 else:
-                    pdf.ln(line_height)  # Add empty line
-
-            pdf.output(str(file_path))
-            logger.debug(f"Wrote PDF to {file_path} with custom formatting")
+                    # Check if we need a new page
+                    if y_pos > page.rect.height - 50:
+                        text_writer.write_text(page)
+                        page = doc.new_page()
+                        text_writer = pymupdf.TextWriter(page.rect)
+                        y_pos = 50
+
+                    # Add text to the current page
+                    text_writer.fill_textbox(
+                        pymupdf.Rect(
+                            x_pos, y_pos, page.rect.width - x_pos, y_pos + 15
+                        ),
+                        stripped_line,
+                        font=normal_font,
+                    )
+                    y_pos += 15
+
+            # Write the accumulated text to the last page
+            text_writer.write_text(page)
+
+            # Save the PDF
+            doc.save(str(file_path))
+            doc.close()
+
+            logger.debug(f"Wrote PDF to {file_path} with PyMuPDF formatting")
 
     def _write_csv_file(
         self,
@@ -338,6 +415,7 @@ class FileWriteToolkit(BaseToolkit):
 
     def write_to_file(
         self,
+        title: str,
         content: Union[str, List[List[str]]],
         filename: str,
         encoding: Optional[str] = None,
@@ -351,6 +429,7 @@ class FileWriteToolkit(BaseToolkit):
         and HTML (.html, .htm).
 
         Args:
+            title (str): The title of the document.
             content (Union[str, List[List[str]]]): The content to write to the
                 file. Content format varies by file type:
                 - Text formats (txt, md, html, yaml): string
@@ -388,7 +467,7 @@ class FileWriteToolkit(BaseToolkit):
                 self._write_docx_file(file_path, str(content))
             elif extension == ".pdf":
                 self._write_pdf_file(
-                    file_path, str(content), use_latex=use_latex
+                    file_path, title, str(content), use_latex=use_latex
                 )
             elif extension == ".csv":
                 self._write_csv_file(

camel/toolkits/human_toolkit.py

@@ -22,16 +22,29 @@ logger = logging.getLogger(__name__)
 
 
 class HumanToolkit(BaseToolkit):
-    r"""A class representing a toolkit for human interaction."""
+    r"""A class representing a toolkit for human interaction.
+
+    Note:
+        This toolkit should be called to send a tidy message to the user to
+        keep them informed.
+    """
 
     def ask_human_via_console(self, question: str) -> str:
-        r"""Ask a question to the human via the console.
+        r"""Use this tool to ask a question to the user when you are stuck,
+        need clarification, or require a decision to be made. This is a
+        two-way communication channel that will wait for the user's response.
+        You should use it to:
+        - Clarify ambiguous instructions or requirements.
+        - Request missing information that you cannot find (e.g., login
+        credentials, file paths).
+        - Ask for a decision when there are multiple viable options.
+        - Seek help when you encounter an error you cannot resolve on your own.
 
         Args:
-            question (str): The question to ask the human.
+            question (str): The question to ask the user.
 
         Returns:
-            str: The answer from the human.
+            str: The user's response to the question.
         """
         print(f"Question: {question}")
         logger.info(f"Question: {question}")
@@ -40,14 +53,21 @@ class HumanToolkit(BaseToolkit):
         return reply
 
     def send_message_to_user(self, message: str) -> None:
-        r"""Send a message to the user, without waiting for
-        a response. This will send to stdout in a noticeable way.
+        r"""Use this tool to send a tidy message to the user in one short
+        sentence.
 
-        This is guaranteed to reach the user regardless of
-        actual user interface.
+        This one-way tool keeps the user informed about your progress,
+        decisions, or actions. It does not require a response.
+        You should use it to:
+        - Announce what you are about to do (e.g., "I will now search for
+          papers on GUI Agents.").
+        - Report the result of an action (e.g., "I have found 15 relevant
+          papers.").
+        - State a decision (e.g., "I will now analyze the top 10 papers.").
+        - Give a status update during a long-running task.
 
         Args:
-            message (str): The message to send to the user.
+            message (str): The tidy and informative message for the user.
         """
         print(f"\nAgent Message:\n{message}")
         logger.info(f"\nAgent Message:\n{message}")

camel/toolkits/jina_reranker_toolkit.py

@@ -34,7 +34,7 @@ class JinaRerankerToolkit(BaseToolkit):
     def __init__(
         self,
         timeout: Optional[float] = None,
-        model_name: Optional[str] = "jinaai/jina-reranker-m0",
+        model_name: str = "jinaai/jina-reranker-m0",
         device: Optional[str] = None,
         use_api: bool = True,
     ) -> None:
@@ -44,9 +44,8 @@ class JinaRerankerToolkit(BaseToolkit):
             timeout (Optional[float]): The timeout value for API requests
                 in seconds. If None, no timeout is applied.
                 (default: :obj:`None`)
-            model_name (Optional[str]): The reranker model name. If None,
-                will use the default model.
-                (default: :obj:`None`)
+            model_name (str): The reranker model name.
+                (default: :obj:`"jinaai/jina-reranker-m0"`)
             device (Optional[str]): Device to load the model on. If None,
                 will use CUDA if available, otherwise CPU.
                 Only effective when use_api=False.

camel/toolkits/non_visual_browser_toolkit/browser_non_visual_toolkit.py

@@ -80,7 +80,28 @@ class BrowserNonVisualToolkit(BaseToolkit):
                 return
 
             if loop.is_closed():
-                # Event loop already closed → cannot run async cleanup
+                # The default loop is closed, create a *temporary* loop just
+                # for cleanup so that Playwright / asyncio transports are
+                # gracefully shut down.  This avoids noisy warnings such as
+                # "RuntimeError: Event loop is closed" when the program
+                # exits.
+                try:
+                    tmp_loop = asyncio.new_event_loop()
+                    try:
+                        asyncio.set_event_loop(tmp_loop)
+                        tmp_loop.run_until_complete(self.close_browser())
+                    finally:
+                        # Best-effort shutdown of async generators and loop
+                        # itself (Python ≥3.6).
+                        if hasattr(tmp_loop, "shutdown_asyncgens"):
+                            tmp_loop.run_until_complete(
+                                tmp_loop.shutdown_asyncgens()
+                            )
+                        tmp_loop.close()
+                finally:
+                    # Ensure no subsequent get_event_loop() picks up a now
+                    # closed temporary loop.
+                    asyncio.set_event_loop(None)
                 return
 
             if loop.is_running():
@@ -155,7 +176,7 @@ class BrowserNonVisualToolkit(BaseToolkit):
             self._agent = None
 
         # Close session
-        await self._session.close()
+        await NVBrowserSession.close_all_sessions()
         return "Browser session closed."
 
     async def visit_page(self, url: str) -> Dict[str, str]:

camel/toolkits/non_visual_browser_toolkit/nv_browser_session.py

@@ -13,8 +13,11 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional
+
+from camel.logger import get_logger
 
 from .actions import ActionExecutor
 from .snapshot import PageSnapshot
@@ -28,6 +31,9 @@ if TYPE_CHECKING:
     )
 
 
+logger = get_logger(__name__)
+
+
 class NVBrowserSession:
     """Lightweight wrapper around Playwright for non-visual (headless)
     browsing.
@@ -35,15 +41,37 @@ class NVBrowserSession:
     It provides a single *Page* instance plus helper utilities (snapshot &
     executor).  Multiple toolkits or agents can reuse this class without
     duplicating Playwright setup code.
+
+    This class is a singleton per event-loop.
     """
 
     # Configuration constants
     DEFAULT_NAVIGATION_TIMEOUT = 10000  # 10 seconds
     NETWORK_IDLE_TIMEOUT = 5000  # 5 seconds
 
+    _sessions: ClassVar[
+        Dict[asyncio.AbstractEventLoop, "NVBrowserSession"]
+    ] = {}
+
+    _initialized: bool
+
+    def __new__(
+        cls, *, headless: bool = True, user_data_dir: Optional[str] = None
+    ):
+        loop = asyncio.get_running_loop()
+        if loop not in cls._sessions:
+            instance = super().__new__(cls)
+            instance._initialized = False
+            cls._sessions[loop] = instance
+        return cls._sessions[loop]
+
     def __init__(
         self, *, headless: bool = True, user_data_dir: Optional[str] = None
     ):
+        if self._initialized:
+            return
+        self._initialized = True
+
         self._headless = headless
         self._user_data_dir = user_data_dir
 
@@ -56,8 +84,6 @@ class NVBrowserSession:
         self.executor: Optional[ActionExecutor] = None
 
         # Protect browser initialisation against concurrent calls
-        import asyncio
-
         self._ensure_lock: "asyncio.Lock" = asyncio.Lock()
 
     # ------------------------------------------------------------------
@@ -93,10 +119,6 @@ class NVBrowserSession:
             self._browser = await pl.chromium.launch(headless=self._headless)
             self._context = await self._browser.new_context()
 
-        from camel.logger import get_logger
-
-        _dbg_logger = get_logger(__name__)
-
         # Reuse an already open page (persistent context may restore last
         # session)
         if self._context.pages:
@@ -105,7 +127,7 @@ class NVBrowserSession:
             self._page = await self._context.new_page()
 
         # Debug information to help trace concurrency issues
-        _dbg_logger.debug(
+        logger.debug(
             "Session %s created browser=%s context=%s page=%s (url=%s)",
             hex(id(self)),
             hex(id(self._browser)) if self._browser else None,
@@ -122,6 +144,11 @@ class NVBrowserSession:
         r"""Close all browser resources, ensuring cleanup even if some
         operations fail.
         """
+        # The close method will now only close the *current* event-loop's
+        # browser instance.  Use `close_all_sessions` for a full cleanup.
+        await self._close_session()
+
+    async def _close_session(self) -> None:
         errors: list[str] = []
 
         # Close context first (which closes pages)
@@ -151,13 +178,28 @@ class NVBrowserSession:
 
         # Log errors if any occurred during cleanup
         if errors:
-            from camel.logger import get_logger
-
-            logger = get_logger(__name__)
             logger.warning(
                 "Errors during browser session cleanup: %s", "; ".join(errors)
             )
 
+    @classmethod
+    async def close_all_sessions(cls) -> None:
+        r"""Iterate over all stored sessions and close them."""
+        for loop, session in cls._sessions.items():
+            if loop.is_running():
+                await session._close_session()
+            else:
+                try:
+                    if not loop.is_closed():
+                        loop.run_until_complete(session._close_session())
+                except Exception as e:
+                    logger.warning(
+                        "Failed to close session for loop %s: %s",
+                        hex(id(loop)),
+                        e,
+                    )
+        cls._sessions.clear()
+
     # ------------------------------------------------------------------
     # Convenience wrappers around common actions
     # ------------------------------------------------------------------