ag2 0.10.2__py3-none-any.whl

autogen/agents/experimental/slack/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .slack import SlackAgent
+
+__all__ = ["SlackAgent"]

autogen/agents/experimental/slack/slack.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from .... import ConversableAgent
+from ....doc_utils import export_module
+from ....tools.experimental import SlackRetrieveRepliesTool, SlackRetrieveTool, SlackSendTool
+
+__all__ = ["SlackAgent"]
+
+
+@export_module("autogen.agents.experimental")
+class SlackAgent(ConversableAgent):
+    """An agent that can send messages and retrieve messages on Slack."""
+
+    DEFAULT_SYSTEM_MESSAGE = (
+        "You are a helpful AI assistant that communicates through Slack. "
+        "Remember that Slack uses Markdown-like formatting and has message length limits. "
+        "Keep messages clear and concise, and consider using appropriate formatting when helpful."
+    )
+
+    def __init__(
+        self,
+        name: str,
+        system_message: str | None = None,
+        *,
+        bot_token: str,
+        channel_id: str,
+        has_writing_instructions: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the SlackAgent.
+
+        Args:
+            name: name of the agent.
+            system_message: system message for the ChatCompletion inference.
+            bot_token: Bot User OAuth Token starting with "xoxb-".
+            channel_id: Channel ID where messages will be sent.
+            has_writing_instructions: Whether to add writing instructions to the system message. Defaults to True.
+            **kwargs: Additional keyword arguments passed to the parent ConversableAgent class.
+        """
+        slack_system_message = system_message or self.DEFAULT_SYSTEM_MESSAGE
+
+        self._send_tool = SlackSendTool(bot_token=bot_token, channel_id=channel_id)
+        self._retrieve_tool = SlackRetrieveTool(bot_token=bot_token, channel_id=channel_id)
+        self._retrieve_replies_tool = SlackRetrieveRepliesTool(bot_token=bot_token, channel_id=channel_id)
+
+        # Add formatting instructions
+        if has_writing_instructions:
+            formatting_instructions = (
+                "\nFormat guidelines for Slack:\n"
+                "Format guidelines for Slack:\n"
+                "1. Max message length: 40,000 characters\n"
+                "2. Supports Markdown-like formatting:\n"
+                "   - *text* for italic\n"
+                "   - **text** for bold\n"
+                "   - `code` for inline code\n"
+                "   - ```code block``` for multi-line code\n"
+                "3. Supports message threading for organized discussions\n"
+                "4. Can use :emoji_name: for emoji reactions\n"
+                "5. Supports block quotes with > prefix\n"
+                "6. Can use <!here> or <!channel> for notifications"
+            )
+
+            slack_system_message = slack_system_message + formatting_instructions
+
+        super().__init__(name=name, system_message=slack_system_message, **kwargs)
+
+        self.register_for_llm()(self._send_tool)
+        self.register_for_llm()(self._retrieve_tool)
+        self.register_for_llm()(self._retrieve_replies_tool)

autogen/agents/experimental/telegram/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .telegram import TelegramAgent
+
+__all__ = ["TelegramAgent"]

autogen/agents/experimental/telegram/telegram.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from .... import ConversableAgent
+from ....doc_utils import export_module
+from ....tools.experimental import TelegramRetrieveTool, TelegramSendTool
+
+__all__ = ["TelegramAgent"]
+
+
+@export_module("autogen.agents.experimental")
+class TelegramAgent(ConversableAgent):
+    """An agent that can send messages and retrieve messages on Telegram."""
+
+    DEFAULT_SYSTEM_MESSAGE = (
+        "You are a helpful AI assistant that communicates through Telegram. "
+        "Remember that Telegram uses Markdown-like formatting and has message length limits. "
+        "Keep messages clear and concise, and consider using appropriate formatting when helpful."
+    )
+
+    def __init__(
+        self,
+        name: str,
+        system_message: str | None = None,
+        *,
+        api_id: str,
+        api_hash: str,
+        chat_id: str,
+        has_writing_instructions: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the TelegramAgent.
+
+        Args:
+            name: The name of the agent.
+            system_message: The system message for the agent.
+            api_id: Telegram API ID from https://my.telegram.org/apps.
+            api_hash: Telegram API hash from https://my.telegram.org/apps.
+            chat_id: The ID of the destination (Channel, Group, or User ID).
+            has_writing_instructions (bool): Whether to add writing instructions to the system message. Defaults to True.
+            **kwargs: Additional keyword arguments passed to the parent ConversableAgent class.
+        """
+        telegram_system_message = system_message or self.DEFAULT_SYSTEM_MESSAGE
+
+        self._send_tool = TelegramSendTool(api_id=api_id, api_hash=api_hash, chat_id=chat_id)
+        self._retrieve_tool = TelegramRetrieveTool(api_id=api_id, api_hash=api_hash, chat_id=chat_id)
+
+        # Add formatting instructions
+        if has_writing_instructions:
+            formatting_instructions = (
+                "\nFormat guidelines for Telegram:\n"
+                "1. Max message length: 4096 characters\n"
+                "2. HTML formatting:\n"
+                "   - <b>bold</b>\n"
+                "   - <i>italic</i>\n"
+                "   - <code>code</code>\n"
+                "   - <pre>code block</pre>\n"
+                "   - <a href='URL'>link</a>\n"
+                "   - <u>underline</u>\n"
+                "   - <s>strikethrough</s>\n"
+                "3. HTML rules:\n"
+                "   - Tags must be properly closed\n"
+                "   - Can't nest identical tags\n"
+                "   - Links require full URLs (with http://)\n"
+                "4. Supports @mentions and emoji"
+            )
+
+            telegram_system_message = telegram_system_message + formatting_instructions
+
+        super().__init__(name=name, system_message=telegram_system_message, **kwargs)
+
+        self.register_for_llm()(self._send_tool)
+        self.register_for_llm()(self._retrieve_tool)

autogen/agents/experimental/websurfer/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .websurfer import WebSurferAgent
+
+__all__ = ["WebSurferAgent"]

autogen/agents/experimental/websurfer/websurfer.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Literal
+
+from .... import ConversableAgent
+from ....doc_utils import export_module
+from ....llm_config import LLMConfig
+from ....tools import Tool
+from ....tools.experimental import (
+    BrowserUseTool,
+    Crawl4AITool,
+    DuckDuckGoSearchTool,
+    FirecrawlTool,
+    PerplexitySearchTool,
+    SearxngSearchTool,
+    TavilySearchTool,
+)
+
+__all__ = ["WebSurferAgent"]
+
+
+@export_module("autogen.agents.experimental")
+class WebSurferAgent(ConversableAgent):
+    """An agent that uses web tools to interact with the web."""
+
+    def __init__(
+        self,
+        *,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        web_tool_llm_config: LLMConfig | dict[str, Any] | None = None,
+        web_tool: Literal[
+            "browser_use", "crawl4ai", "duckduckgo", "firecrawl", "perplexity", "tavily", "searxng"
+        ] = "browser_use",
+        web_tool_kwargs: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the WebSurferAgent.
+
+        Args:
+            llm_config: The LLM configuration.
+            web_tool_llm_config: The LLM configuration for the web tool. If not provided, the llm_config will be used.
+            web_tool: The web tool to use. Defaults to "browser_use".
+            web_tool_kwargs: The keyword arguments for the web tool. Defaults to None.
+            **kwargs: Additional keyword arguments passed to the parent ConversableAgent class.
+        """
+        llm_config = LLMConfig.get_current_llm_config(llm_config)  # type: ignore[arg-type]
+        web_tool_kwargs = web_tool_kwargs if web_tool_kwargs else {}
+        web_tool_llm_config = web_tool_llm_config if web_tool_llm_config else llm_config
+        if web_tool == "browser_use":
+            self.tool: Tool = BrowserUseTool(llm_config=web_tool_llm_config, **web_tool_kwargs)  # type: ignore[arg-type]
+        elif web_tool == "crawl4ai":
+            self.tool = Crawl4AITool(llm_config=web_tool_llm_config, **web_tool_kwargs)
+        elif web_tool == "firecrawl":
+            self.tool = FirecrawlTool(llm_config=web_tool_llm_config, **web_tool_kwargs)
+        elif web_tool == "perplexity":
+            self.tool = PerplexitySearchTool(**web_tool_kwargs)
+        elif web_tool == "tavily":
+            self.tool = TavilySearchTool(llm_config=web_tool_llm_config, **web_tool_kwargs)
+        elif web_tool == "duckduckgo":
+            self.tool = DuckDuckGoSearchTool(**web_tool_kwargs)
+        elif web_tool == "searxng":
+            self.tool = SearxngSearchTool(**web_tool_kwargs)
+        else:
+            raise ValueError(f"Unsupported {web_tool=}.")
+
+        super().__init__(llm_config=llm_config, **kwargs)
+
+        self.register_for_llm()(self.tool)

autogen/agents/experimental/wikipedia/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .wikipedia import WikipediaAgent
+
+__all__ = ["WikipediaAgent"]

autogen/agents/experimental/wikipedia/wikipedia.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from .... import ConversableAgent
+from ....doc_utils import export_module
+from ....tools.experimental import WikipediaPageLoadTool, WikipediaQueryRunTool
+
+
+@export_module("autogen.agents.experimental")
+class WikipediaAgent(ConversableAgent):
+    """An AI agent that leverages Wikipedia tools to provide accurate, concise answers
+    to user queries.
+
+    Tools:
+        - WikipediaQueryRunTool: searches Wikipedia for relevant article titles.
+        - WikipediaPageLoadTool: loads full Wikipedia pages (and metadata) for in‑depth content.
+
+    Attributes:
+        _query_run_tool (WikipediaQueryRunTool): for running title/keyword searches.
+        _page_load_tool (WikipediaPageLoadTool): for fetching full page content.
+
+    Parameters:
+        system_message (Optional[Union[str, List[str]]]):
+            Custom system prompt(s). If None, DEFAULT_SYSTEM_MESSAGE is used.
+            Must be a str or a list of strings, otherwise raises ValueError.
+        format_instructions (Optional[str]): Extra formatting instructions to append.
+        language (str): ISO code for the Wikipedia language edition (default: "en").
+        top_k (int): Number of top search results to return (default: 2).
+        **kwargs: Passed through to the base ConversableAgent.
+
+    Raises:
+        ValueError: If `system_message` is not a str or list of str.
+    """
+
+    DEFAULT_SYSTEM_MESSAGE = (
+        "You are a knowledgeable AI assistant with access to Wikipedia.\n"
+        "Use your tools when necessary. Respond to user queries by providing accurate and concise information.\n"
+        "If a question requires external data, utilize the appropriate tool to retrieve it."
+    )
+
+    def __init__(
+        self,
+        system_message: str | list[str] | None = None,
+        format_instructions: str | None = None,
+        language: str = "en",
+        top_k: int = 2,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the WikipediaAgent with optional custom prompts and tools.
+
+        Args:
+            system_message (Optional[Union[str, List[str]]]):
+                Custom system prompt(s). If None, DEFAULT_SYSTEM_MESSAGE is used.
+                Must be a str or list of strings.
+            format_instructions (Optional[str]): Extra formatting instructions to append.
+            language (str): Wikipedia language code (default: "en").
+            top_k (int): How many top search results to fetch (default: 2).
+            **kwargs: Other parameters for ConversableAgent.
+
+        Raises:
+            ValueError: If `system_message` is not a str or list of str.
+        """
+        # Use explicit system_message or fall back to default
+        system_message = system_message or self.DEFAULT_SYSTEM_MESSAGE
+
+        # Append formatting instructions if provided
+        if format_instructions is not None:
+            instructions = f"\n\nFollow this format:\n\n{format_instructions}"
+            if isinstance(system_message, list):
+                system_message.append(instructions)
+            elif isinstance(system_message, str):
+                system_message = system_message + instructions
+            else:
+                raise ValueError(f"system_message must be str or list[str], got {type(system_message).__name__}")
+
+        # Initialize Wikipedia tools
+        self._query_run_tool = WikipediaQueryRunTool(language=language, top_k=top_k)
+        self._page_load_tool = WikipediaPageLoadTool(language=language, top_k=top_k)
+
+        # Initialize the base ConversableAgent
+        super().__init__(system_message=system_message, **kwargs)
+
+        # Register tools for LLM recommendations
+        self.register_for_llm()(self._query_run_tool)
+        self.register_for_llm()(self._page_load_tool)

autogen/browser_utils.py

@@ -0,0 +1,309 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+import io
+import mimetypes
+import os
+import re
+import uuid
+from contextlib import suppress
+from typing import Any
+from urllib.parse import urljoin, urlparse
+
+from .import_utils import optional_import_block, require_optional_import
+
+with optional_import_block():
+    import markdownify
+    import requests
+    from bs4 import BeautifulSoup
+
+# Optional PDF support
+with optional_import_block() as result:
+    import pdfminer
+    import pdfminer.high_level
+
+IS_PDF_CAPABLE = result.is_successful
+
+# Other optional dependencies
+with optional_import_block():
+    import pathvalidate
+
+
+@require_optional_import(["markdownify", "requests", "bs4", "pdfminer", "pathvalidate"], "websurfer")
+class SimpleTextBrowser:
+    """(In preview) An extremely simple text-based web browser comparable to Lynx. Suitable for Agentic use."""
+
+    def __init__(
+        self,
+        start_page: str | None = None,
+        viewport_size: int | None = 1024 * 8,
+        downloads_folder: str | None | None = None,
+        bing_base_url: str = "https://api.bing.microsoft.com/v7.0/search",
+        bing_api_key: str | None | None = None,
+        request_kwargs: dict[str, Any] | None | None = None,
+    ):
+        """Initialize the browser with the given parameters.
+
+        Args:
+            start_page (Optional[str], optional): The initial page to load. Defaults to None.
+            viewport_size (Optional[int], optional): The number of characters to display per page. Defaults to 1024 * 8.
+            downloads_folder (Optional[Union[str, None]], optional): The folder to save downloads to. Defaults to None.
+            bing_base_url (str, optional): The base URL for Bing searches. Defaults to "https://api.bing.microsoft.com/v7.0/search".
+            bing_api_key (Optional[Union[str, None]], optional): The API key for Bing searches. Defaults to None.
+            request_kwargs (Optional[Union[dict[str, Any], None]], optional): Additional keyword arguments to pass to the requests library. Defaults to None.
+        """
+        self.start_page: str = start_page if start_page else "about:blank"
+        self.viewport_size = viewport_size  # Applies only to the standard uri types
+        self.downloads_folder = downloads_folder
+        self.history: list[str] = []
+        self.page_title: str | None = None
+        self.viewport_current_page = 0
+        self.viewport_pages: list[tuple[int, int]] = []
+        self.set_address(self.start_page)
+        self.bing_base_url = bing_base_url
+        self.bing_api_key = bing_api_key
+        self.request_kwargs = request_kwargs
+
+        self._page_content = ""
+
+    @property
+    def address(self) -> str:
+        """Return the address of the current page."""
+        return self.history[-1]
+
+    def set_address(self, uri_or_path: str) -> None:
+        """Set the address of the current page.
+
+        Args:
+            uri_or_path (str): The URI or path to set as the current page.
+        """
+        self.history.append(uri_or_path)
+
+        # Handle special URIs
+        if uri_or_path == "about:blank":
+            self._set_page_content("")
+        elif uri_or_path.startswith("bing:"):
+            self._bing_search(uri_or_path[len("bing:") :].strip())
+        else:
+            if not uri_or_path.startswith("http:") and not uri_or_path.startswith("https:"):
+                uri_or_path = urljoin(self.address, uri_or_path)
+                self.history[-1] = uri_or_path  # Update the address with the fully-qualified path
+            self._fetch_page(uri_or_path)
+
+        self.viewport_current_page = 0
+
+    @property
+    def viewport(self) -> str:
+        """Return the content of the current viewport."""
+        bounds = self.viewport_pages[self.viewport_current_page]
+        return self.page_content[bounds[0] : bounds[1]]
+
+    @property
+    def page_content(self) -> str:
+        """Return the full contents of the current page."""
+        return self._page_content
+
+    def _set_page_content(self, content: str) -> None:
+        """Sets the text content of the current page."""
+        self._page_content = content
+        self._split_pages()
+        if self.viewport_current_page >= len(self.viewport_pages):
+            self.viewport_current_page = len(self.viewport_pages) - 1
+
+    def page_down(self) -> None:
+        """Move the viewport down by one page."""
+        self.viewport_current_page = min(self.viewport_current_page + 1, len(self.viewport_pages) - 1)
+
+    def page_up(self) -> None:
+        """Move the viewport up by one page."""
+        self.viewport_current_page = max(self.viewport_current_page - 1, 0)
+
+    def visit_page(self, path_or_uri: str) -> str:
+        """Update the address, visit the page, and return the content of the viewport.
+
+        Args:
+            path_or_uri (str): The URI or path to visit.
+        """
+        self.set_address(path_or_uri)
+        return self.viewport
+
+    def _split_pages(self) -> None:
+        # Split only regular pages
+        if not self.address.startswith("http:") and not self.address.startswith("https:"):
+            self.viewport_pages = [(0, len(self._page_content))]
+            return
+
+        # Handle empty pages
+        if len(self._page_content) == 0:
+            self.viewport_pages = [(0, 0)]
+            return
+
+        # Break the viewport into pages
+        self.viewport_pages = []
+        start_idx = 0
+        while start_idx < len(self._page_content):
+            end_idx = min(start_idx + self.viewport_size, len(self._page_content))  # type: ignore[operator]
+            # Adjust to end on a space
+            while end_idx < len(self._page_content) and self._page_content[end_idx - 1] not in [" ", "\t", "\r", "\n"]:
+                end_idx += 1
+            self.viewport_pages.append((start_idx, end_idx))
+            start_idx = end_idx
+
+    def _bing_api_call(self, query: str) -> dict[str, dict[str, list[dict[str, str | dict[str, str]]]]]:
+        # Make sure the key was set
+        if self.bing_api_key is None:
+            raise ValueError("Missing Bing API key.")
+
+        # Prepare the request parameters
+        request_kwargs = self.request_kwargs.copy() if self.request_kwargs is not None else {}
+
+        if "headers" not in request_kwargs:
+            request_kwargs["headers"] = {}
+        request_kwargs["headers"]["Ocp-Apim-Subscription-Key"] = self.bing_api_key
+
+        if "params" not in request_kwargs:
+            request_kwargs["params"] = {}
+        request_kwargs["params"]["q"] = query
+        request_kwargs["params"]["textDecorations"] = False
+        request_kwargs["params"]["textFormat"] = "raw"
+
+        request_kwargs["stream"] = False
+
+        # Make the request
+        response = requests.get(self.bing_base_url, **request_kwargs)
+        response.raise_for_status()
+        results = response.json()
+
+        return results  # type: ignore[no-any-return]
+
+    def _bing_search(self, query: str) -> None:
+        results = self._bing_api_call(query)
+
+        web_snippets: list[str] = []
+        idx = 0
+        for page in results["webPages"]["value"]:
+            idx += 1
+            web_snippets.append(f"{idx}. [{page['name']}]({page['url']})\n{page['snippet']}")
+            if "deepLinks" in page:
+                for dl in page["deepLinks"]:
+                    idx += 1
+                    web_snippets.append(
+                        f"{idx}. [{dl['name']}]({dl['url']})\n{dl.get('snippet', '')}"  # type: ignore[index]
+                    )
+
+        news_snippets = []
+        if "news" in results:
+            for page in results["news"]["value"]:
+                idx += 1
+                news_snippets.append(f"{idx}. [{page['name']}]({page['url']})\n{page['description']}")
+
+        self.page_title = f"{query} - Search"
+
+        content = (
+            f"A Bing search for '{query}' found {len(web_snippets) + len(news_snippets)} results:\n\n## Web Results\n"
+            + "\n\n".join(web_snippets)
+        )
+        if len(news_snippets) > 0:
+            content += "\n\n## News Results:\n" + "\n\n".join(news_snippets)
+        self._set_page_content(content)
+
+    def _fetch_page(self, url: str) -> None:
+        try:
+            # Prepare the request parameters
+            request_kwargs = self.request_kwargs.copy() if self.request_kwargs is not None else {}
+            request_kwargs["stream"] = True
+
+            # Send a HTTP request to the URL
+            response = requests.get(url, **request_kwargs)
+            response.raise_for_status()
+
+            # If the HTTP request returns a status code 200, proceed
+            if response.status_code == 200:
+                content_type = response.headers.get("content-type", "")
+                for ct in ["text/html", "text/plain", "application/pdf"]:
+                    if ct in content_type.lower():
+                        content_type = ct
+                        break
+
+                if content_type == "text/html":
+                    # Get the content of the response
+                    html = ""
+                    for chunk in response.iter_content(chunk_size=512, decode_unicode=True):
+                        html += chunk
+
+                    soup = BeautifulSoup(html, "html.parser")
+
+                    # Remove javascript and style blocks
+                    for script in soup(["script", "style"]):
+                        script.extract()
+
+                    # Convert to markdown -- Wikipedia gets special attention to get a clean version of the page
+                    if url.startswith("https://en.wikipedia.org/"):
+                        body_elm = soup.find("div", {"id": "mw-content-text"})
+                        title_elm = soup.find("span", {"class": "mw-page-title-main"})
+
+                        if body_elm:
+                            # What's the title
+                            main_title = soup.title.string
+                            if title_elm and len(title_elm) > 0:
+                                main_title = title_elm.string
+                            webpage_text = (
+                                "# " + main_title + "\n\n" + markdownify.MarkdownConverter().convert_soup(body_elm)
+                            )
+                        else:
+                            webpage_text = markdownify.MarkdownConverter().convert_soup(soup)
+                    else:
+                        webpage_text = markdownify.MarkdownConverter().convert_soup(soup)
+
+                    # Convert newlines
+                    webpage_text = re.sub(r"\r\n", "\n", webpage_text)
+
+                    # Remove excessive blank lines
+                    self.page_title = soup.title.string
+                    self._set_page_content(re.sub(r"\n{2,}", "\n\n", webpage_text).strip())
+                elif content_type == "text/plain":
+                    # Get the content of the response
+                    plain_text = ""
+                    for chunk in response.iter_content(chunk_size=512, decode_unicode=True):
+                        plain_text += chunk
+
+                    self.page_title = None
+                    self._set_page_content(plain_text)
+                elif IS_PDF_CAPABLE and content_type == "application/pdf":
+                    pdf_data = io.BytesIO(response.raw.read())
+                    self.page_title = None
+                    self._set_page_content(pdfminer.high_level.extract_text(pdf_data))
+                elif self.downloads_folder is not None:
+                    # Try producing a safe filename
+                    fname = None
+                    with suppress(NameError):
+                        fname = pathvalidate.sanitize_filename(os.path.basename(urlparse(url).path)).strip()
+
+                    # No suitable name, so make one
+                    if fname is None:
+                        extension = mimetypes.guess_extension(content_type)
+                        if extension is None:
+                            extension = ".download"
+                        fname = str(uuid.uuid4()) + extension
+
+                    # Open a file for writing
+                    download_path = os.path.abspath(os.path.join(self.downloads_folder, fname))
+                    with open(download_path, "wb") as fh:
+                        for chunk in response.iter_content(chunk_size=512):
+                            fh.write(chunk)
+
+                    # Return a page describing what just happened
+                    self.page_title = "Download complete."
+                    self._set_page_content(f"Downloaded '{url}' to '{download_path}'.")
+                else:
+                    self.page_title = f"Error - Unsupported Content-Type '{content_type}'"
+                    self._set_page_content(self.page_title)
+            else:
+                self.page_title = "Error"
+                self._set_page_content("Failed to retrieve " + url)
+        except requests.exceptions.RequestException as e:
+            self.page_title = "Error"
+            self._set_page_content(str(e))

autogen/cache/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from .abstract_cache_base import AbstractCache
+from .cache import Cache
+
+__all__ = ["AbstractCache", "Cache"]