langroid 0.56.19__py3-none-any.whl → 0.58.0__py3-none-any.whl

langroid/agent/chat_document.py

@@ -217,25 +217,29 @@ class ChatDocument(Document):
         """
         tool_type = ""  # FUNC or TOOL
         tool = ""  # tool name or function name
-        oai_tools = (
-            []
-            if self.oai_tool_calls is None
-            else [t for t in self.oai_tool_calls if t.function is not None]
-        )
-        if self.function_call is not None:
-            tool_type = "FUNC"
-            tool = self.function_call.name
-        elif len(oai_tools) > 0:
-            tool_type = "OAI_TOOL"
-            tool = ",".join(t.function.name for t in oai_tools)  # type: ignore
-        else:
-            try:
-                json_tools = self.get_tool_names()
-            except Exception:
-                json_tools = []
-            if json_tools != []:
-                tool_type = "TOOL"
-                tool = json_tools[0]
+
+        # Skip tool detection for system messages - they contain tool instructions,
+        # not actual tool calls
+        if self.metadata.sender != Entity.SYSTEM:
+            oai_tools = (
+                []
+                if self.oai_tool_calls is None
+                else [t for t in self.oai_tool_calls if t.function is not None]
+            )
+            if self.function_call is not None:
+                tool_type = "FUNC"
+                tool = self.function_call.name
+            elif len(oai_tools) > 0:
+                tool_type = "OAI_TOOL"
+                tool = ",".join(t.function.name for t in oai_tools)  # type: ignore
+            else:
+                try:
+                    json_tools = self.get_tool_names()
+                except Exception:
+                    json_tools = []
+                if json_tools != []:
+                    tool_type = "TOOL"
+                    tool = json_tools[0]
         recipient = self.metadata.recipient
         content = self.content
         sender_entity = self.metadata.sender
@@ -340,6 +344,50 @@ class ChatDocument(Document):
             ),
         )
 
+    @staticmethod
+    def from_LLMMessage(
+        message: LLMMessage,
+        sender_name: str = "",
+        recipient: str = "",
+    ) -> "ChatDocument":
+        """
+        Convert LLMMessage to ChatDocument.
+
+        Args:
+            message (LLMMessage): LLMMessage to convert.
+            sender_name (str): Name of the sender. Defaults to "".
+            recipient (str): Name of the recipient. Defaults to "".
+
+        Returns:
+            ChatDocument: ChatDocument representation of this LLMMessage.
+        """
+        # Map LLMMessage Role to ChatDocument Entity
+        role_to_entity = {
+            Role.USER: Entity.USER,
+            Role.SYSTEM: Entity.SYSTEM,
+            Role.ASSISTANT: Entity.LLM,
+            Role.FUNCTION: Entity.LLM,
+            Role.TOOL: Entity.LLM,
+        }
+
+        sender_entity = role_to_entity.get(message.role, Entity.USER)
+
+        return ChatDocument(
+            content=message.content or "",
+            content_any=message.content,
+            files=message.files,
+            function_call=message.function_call,
+            oai_tool_calls=message.tool_calls,
+            metadata=ChatDocMetaData(
+                source=sender_entity,
+                sender=sender_entity,
+                sender_name=sender_name,
+                recipient=recipient,
+                oai_tool_id=message.tool_call_id,
+                tool_ids=[message.tool_id] if message.tool_id else [],
+            ),
+        )
+
     @staticmethod
     def to_LLMMessage(
         message: Union[str, "ChatDocument"],

langroid/agent/task.py

@@ -55,6 +55,7 @@ from langroid.utils.constants import (
     SEND_TO,
     USER_QUIT_STRINGS,
 )
+from langroid.utils.html_logger import HTMLLogger
 from langroid.utils.logging import RichFileLogger, setup_file_logger
 from langroid.utils.object_registry import scheduled_cleanup
 from langroid.utils.system import hash
@@ -154,6 +155,7 @@ class TaskConfig(BaseModel):
     restart_as_subtask: bool = False
     logs_dir: str = "logs"
     enable_loggers: bool = True
+    enable_html_logging: bool = True
     addressing_prefix: str = ""
     allow_subtask_multi_oai_tools: bool = True
     recognize_string_signals: bool = True
@@ -343,6 +345,7 @@ class Task:
         self.session_id: str = ""
         self.logger: None | RichFileLogger = None
         self.tsv_logger: None | logging.Logger = None
+        self.html_logger: Optional[HTMLLogger] = None
         self.color_log: bool = False if settings.notebook else True
 
         self.n_stalled_steps = 0  # how many consecutive steps with no progress?
@@ -637,7 +640,20 @@ class Task:
 
         self._show_pending_message_if_debug()
         self.init_loggers()
-        self.log_message(Entity.USER, self.pending_message)
+        # Log system message if it exists
+        if (
+            hasattr(self.agent, "_create_system_and_tools_message")
+            and hasattr(self.agent, "system_message")
+            and self.agent.system_message
+        ):
+            system_msg = self.agent._create_system_and_tools_message()
+            system_message_chat_doc = ChatDocument.from_LLMMessage(
+                system_msg,
+                sender_name=self.name or "system",
+            )
+            # log the system message
+            self.log_message(Entity.SYSTEM, system_message_chat_doc, mark=True)
+        self.log_message(Entity.USER, self.pending_message, mark=True)
         return self.pending_message
 
     def init_loggers(self) -> None:
@@ -667,6 +683,34 @@ class Task:
             header = ChatDocLoggerFields().tsv_header()
             self.tsv_logger.info(f" \tTask\tResponder\t{header}")
 
+        # HTML logger
+        if self.config.enable_html_logging:
+            if (
+                self.caller is not None
+                and hasattr(self.caller, "html_logger")
+                and self.caller.html_logger is not None
+            ):
+                self.html_logger = self.caller.html_logger
+            elif not hasattr(self, "html_logger") or self.html_logger is None:
+                from langroid.utils.html_logger import HTMLLogger
+
+                model_info = ""
+                if (
+                    hasattr(self, "agent")
+                    and hasattr(self.agent, "config")
+                    and hasattr(self.agent.config, "llm")
+                ):
+                    model_info = getattr(self.agent.config.llm, "chat_model", "")
+                self.html_logger = HTMLLogger(
+                    filename=self.name,
+                    log_dir=self.config.logs_dir,
+                    model_info=model_info,
+                    append=False,
+                )
+                # Log clickable file:// link to the HTML log
+                html_log_path = self.html_logger.file_path.resolve()
+                logger.warning(f"📊 HTML Log: file://{html_log_path}")
+
     def reset_all_sub_tasks(self) -> None:
         """
         Recursively reset message history & state of own agent and
@@ -2037,6 +2081,8 @@ class Task:
             mark (bool, optional): Whether to mark the message as the final result of
                 a `task.step()` call. Defaults to False.
         """
+        from langroid.agent.chat_document import ChatDocLoggerFields
+
         default_values = ChatDocLoggerFields().dict().values()
         msg_str_tsv = "\t".join(str(v) for v in default_values)
         if msg is not None:
@@ -2077,6 +2123,48 @@ class Task:
             resp_str = str(resp)
             self.tsv_logger.info(f"{mark_str}\t{task_name}\t{resp_str}\t{msg_str_tsv}")
 
+        # HTML logger
+        if self.html_logger is not None:
+            if msg is None:
+                # Create a minimal fields object for None messages
+                from langroid.agent.chat_document import ChatDocLoggerFields
+
+                fields_dict = {
+                    "responder": str(resp),
+                    "mark": "*" if mark else "",
+                    "task_name": self.name or "root",
+                    "content": "",
+                    "sender_entity": str(resp),
+                    "sender_name": "",
+                    "recipient": "",
+                    "block": None,
+                    "tool_type": "",
+                    "tool": "",
+                }
+            else:
+                # Get fields from the message
+                fields = msg.log_fields()
+                fields_dict = fields.dict()
+                fields_dict.update(
+                    {
+                        "responder": str(resp),
+                        "mark": "*" if mark else "",
+                        "task_name": self.name or "root",
+                    }
+                )
+
+            # Create a ChatDocLoggerFields-like object for the HTML logger
+            # Create a simple BaseModel subclass dynamically
+            from langroid.pydantic_v1 import BaseModel
+
+            class LogFields(BaseModel):
+                class Config:
+                    extra = "allow"  # Allow extra fields
+
+            # Create instance with the fields from fields_dict
+            log_obj = LogFields(**fields_dict)
+            self.html_logger.log(log_obj)
+
     def _valid_recipient(self, recipient: str) -> bool:
         """
         Is the recipient among the list of responders?
@@ -2335,6 +2423,13 @@ class Task:
         # Check if we matched the entire sequence
         return seq_idx == len(sequence.events)
 
+    def close_loggers(self) -> None:
+        """Close all loggers to ensure clean shutdown."""
+        if hasattr(self, "logger") and self.logger is not None:
+            self.logger.close()
+        if hasattr(self, "html_logger") and self.html_logger is not None:
+            self.html_logger.close()
+
     def _matches_sequence_with_current(
         self,
         msg_chain: List[ChatDocument],

langroid/parsing/url_loader.py

@@ -1,8 +1,9 @@
+import asyncio
 import logging
 import os
 from abc import ABC, abstractmethod
 from tempfile import NamedTemporaryFile
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
 
 import markdownify as md
 from dotenv import load_dotenv
@@ -16,6 +17,16 @@ from langroid.pydantic_v1 import BaseSettings
 if TYPE_CHECKING:
     from firecrawl import FirecrawlApp
 
+    try:
+        from crawl4ai import CrawlResult
+        from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig
+        from crawl4ai.content_scraping_strategy import ContentScrapingStrategy
+        from crawl4ai.deep_crawling import DeepCrawlStrategy
+        from crawl4ai.extraction_strategy import ExtractionStrategy
+        from crawl4ai.markdown_generation_strategy import MarkdownGenerationStrategy
+    except ImportError:
+        raise LangroidImportError("crawl4ai", "crawl-4-ai")
+
 load_dotenv()
 
 logging.getLogger("url_loader").setLevel(logging.WARNING)
@@ -59,6 +70,52 @@ class ExaCrawlerConfig(BaseCrawlerConfig):
         env_prefix = "EXA_"
 
 
+def _resolve_crawl4ai_forward_refs(cls: Any) -> Any:
+    """
+    A class decorator that resolves forward references for fields in a Pydantic
+    model that depend on the optional 'crawl4ai' library.
+    """
+    try:
+        from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig  # noqa: F401
+        from crawl4ai.content_scraping_strategy import (  # noqa: F401
+            ContentScrapingStrategy,
+        )
+        from crawl4ai.deep_crawling import DeepCrawlStrategy  # noqa: F401
+        from crawl4ai.extraction_strategy import ExtractionStrategy  # noqa: F401
+        from crawl4ai.markdown_generation_strategy import (  # noqa: F401
+            MarkdownGenerationStrategy,
+        )
+
+        #  Create a namespace dictionary from locals() but exclude 'cls'.
+        # This prevents the TypeError.
+        namespace = {name: value for name, value in locals().items() if name != "cls"}
+        cls.update_forward_refs(**namespace)
+
+    except ImportError:
+        # If crawl4ai is not installed, do nothing.
+        pass
+    return cls
+
+
+@_resolve_crawl4ai_forward_refs
+class Crawl4aiConfig(BaseCrawlerConfig):
+    """
+    Configuration for the Crawl4aiCrawler.
+    """
+
+    crawl_mode: Literal["simple", "deep"] = "simple"
+    extraction_strategy: Optional["ExtractionStrategy"] = None
+    markdown_strategy: Optional["MarkdownGenerationStrategy"] = None
+    deep_crawl_strategy: Optional["DeepCrawlStrategy"] = None
+    scraping_strategy: Optional["ContentScrapingStrategy"] = None
+
+    browser_config: Optional["BrowserConfig"] = None
+    run_config: Optional["CrawlerRunConfig"] = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
 class BaseCrawler(ABC):
     """Abstract base class for web crawlers."""
 
@@ -163,6 +220,8 @@ class CrawlerFactory:
             return FirecrawlCrawler(config)
         elif isinstance(config, ExaCrawlerConfig):
             return ExaCrawler(config)
+        elif isinstance(config, Crawl4aiConfig):
+            return Crawl4aiCrawler(config)
         else:
             raise ValueError(f"Unsupported crawler configuration type: {type(config)}")
 
@@ -419,6 +478,180 @@ class ExaCrawler(BaseCrawler):
         return docs
 
 
+class Crawl4aiCrawler(BaseCrawler):
+    """
+    Crawler implementation using the crawl4ai library.
+
+    This crawler intelligently dispatches URLs. Standard web pages are rendered
+    and scraped using the crawl4ai browser engine. Direct links to documents
+    (PDF, DOCX, etc.) are delegated to the framework's internal DocumentParser.
+    """
+
+    def __init__(self, config: Crawl4aiConfig) -> None:
+        """Initialize the Crawl4ai crawler."""
+        super().__init__(config)
+        self.config: Crawl4aiConfig = config
+
+    @property
+    def needs_parser(self) -> bool:
+        """
+        Indicates that this crawler relies on the framework's DocumentParser
+        for handling specific file types like PDF, DOCX, etc., which
+        the browser engine cannot parse directly.
+        """
+        return True
+
+    def crawl(self, urls: List[str]) -> List[Document]:
+        """
+        Executes the crawl by separating document URLs from web page URLs.
+
+        - Document URLs (.pdf, .docx, etc.) are processed using `_process_document`.
+        - Web page URLs are handled using the async crawl4ai engine.
+        """
+        all_documents: List[Document] = []
+        webpage_urls: List[str] = []
+
+        # Step 1: Separate URLs into documents and web pages
+        for url in urls:
+            parsed_doc_chunks = self._process_document(url)
+            if parsed_doc_chunks:
+                all_documents.extend(parsed_doc_chunks)
+            else:
+                webpage_urls.append(url)
+
+        # Step 2: Process web page URLs asynchronously
+        if webpage_urls:
+            try:
+                loop = asyncio.get_running_loop()
+                if loop.is_running():
+                    import nest_asyncio
+
+                    nest_asyncio.apply()
+                web_docs = asyncio.run(self._async_crawl(webpage_urls))
+            except RuntimeError:
+                web_docs = asyncio.run(self._async_crawl(webpage_urls))
+
+            all_documents.extend(web_docs)
+
+        return all_documents
+
+    def _translate_result_to_document(
+        self, result: "CrawlResult"
+    ) -> Optional[Document]:
+        """Converts a crawl4ai CrawlResult into the framework's Document format."""
+        if not result.success:
+            logging.warning(
+                f"Crawl4ai failed for URL {result.url}: {result.error_message}"
+            )
+            return None
+
+        content = ""
+        if result.extracted_content:
+            content = result.extracted_content
+        elif result.markdown:
+            if (
+                hasattr(result.markdown, "fit_markdown")
+                and result.markdown.fit_markdown
+            ):
+                content = result.markdown.fit_markdown
+            elif hasattr(result.markdown, "raw_markdown"):
+                content = result.markdown.raw_markdown
+            else:
+                content = str(result.markdown)
+
+        if not content:
+            logging.warning(f"Crawl4ai returned no content for URL {result.url}")
+            return None
+
+        # Extract metadata safely
+        title = "Unknown Title"
+        published_date = "Unknown Date"
+
+        if result.metadata:
+            title = result.metadata.get("title", "Unknown Title")
+            # Try common date field names
+            for date_field in [
+                "published_date",
+                "datePublished",
+                "article:published_time",
+                "pubdate",
+            ]:
+                if date_field in result.metadata:
+                    published_date = result.metadata.get(date_field)
+                    break
+
+        meta = DocMetaData(
+            source=result.url,
+            title=title,
+            published_date=published_date,
+            # Note: source_content is meant for reference content, not metadata
+            # Keeping it minimal as other crawlers don't populate it
+        )
+        return Document(content=content, metadata=meta)
+
+    async def _async_crawl(self, urls: List[str]) -> List[Document]:
+        try:
+            from crawl4ai import AsyncWebCrawler
+
+            # Import configs here for lazy loading
+            from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig
+        except ImportError:
+            raise LangroidImportError(
+                "crawl4ai", "pip install 'crawl4ai[all]' or 'crawl4ai'"
+            )
+
+        # CHANGE 2: Handle the new optional config fields.
+        # Use the user-provided config if it exists, otherwise create a default one.
+        browser_config = self.config.browser_config or BrowserConfig()
+        run_config = self.config.run_config or CrawlerRunConfig()
+
+        if self.config.extraction_strategy:
+            run_config.extraction_strategy = self.config.extraction_strategy
+        if self.config.markdown_strategy:
+            run_config.markdown_generator = self.config.markdown_strategy
+        if self.config.deep_crawl_strategy:
+            run_config.deep_crawl_strategy = self.config.deep_crawl_strategy
+        if self.config.scraping_strategy:
+            run_config.scraping_strategy = self.config.scraping_strategy
+
+        crawled_documents: List[Document] = []
+
+        async with AsyncWebCrawler(config=browser_config) as crawler:
+            if self.config.crawl_mode == "simple":
+                for url in urls:
+                    result = await crawler.arun(url, config=run_config)
+                    doc = self._translate_result_to_document(result)
+                    if doc:
+                        crawled_documents.append(doc)
+
+            elif self.config.crawl_mode == "deep":
+                if not urls:
+                    return []
+                if not run_config.deep_crawl_strategy:
+                    logging.warning(
+                        "Deep crawl mode requires a deep_crawl_strategy in the config."
+                    )
+                    return []
+
+                # In deep crawl mode, `crawl4ai` will discover and crawl pages
+                # starting from the seed URL. It will not process direct document links
+                # found during the deep crawl; it is designed to follow hyperlinks.
+                crawl_results = await crawler.arun(urls[0], config=run_config)
+
+                if isinstance(crawl_results, list):
+                    for result in crawl_results:
+                        doc = self._translate_result_to_document(result)
+                        if doc:
+                            crawled_documents.append(doc)
+                else:
+                    async for result in crawl_results:
+                        doc = self._translate_result_to_document(result)
+                        if doc:
+                            crawled_documents.append(doc)
+
+        return crawled_documents
+
+
 class URLLoader:
     """Loads URLs and extracts text using a specified crawler."""