ag2 0.9.6__py3-none-any.whl → 0.9.8.post1__py3-none-any.whl

autogen/tools/experimental/firecrawl/firecrawl_tool.py

@@ -4,7 +4,7 @@
 
 import logging
 import os
-from typing import Annotated, Any, Optional, Union
+from typing import Annotated, Any
 
 from ....doc_utils import export_module
 from ....import_utils import optional_import_block, require_optional_import
@@ -27,16 +27,15 @@ with optional_import_block():
 def _execute_firecrawl_scrape(
     url: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
-    formats: Optional[list[str]] = None,
-    include_tags: Optional[list[str]] = None,
-    exclude_tags: Optional[list[str]] = None,
-    headers: Optional[dict[str, str]] = None,
-    wait_for: Optional[int] = None,
-    timeout: Optional[int] = None,
+    firecrawl_api_url: str | None = None,
+    formats: list[str] | None = None,
+    include_tags: list[str] | None = None,
+    exclude_tags: list[str] | None = None,
+    headers: dict[str, str] | None = None,
+    wait_for: int | None = None,
+    timeout: int | None = None,
 ) -> dict[str, Any]:
-    """
-    Execute a scrape operation using the Firecrawl API.
+    """Execute a scrape operation using the Firecrawl API.
 
     Args:
         url (str): The URL to scrape.
@@ -78,17 +77,16 @@ def _execute_firecrawl_scrape(
 def _execute_firecrawl_crawl(
     url: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
     limit: int = 5,
-    formats: Optional[list[str]] = None,
-    include_paths: Optional[list[str]] = None,
-    exclude_paths: Optional[list[str]] = None,
-    max_depth: Optional[int] = None,
+    formats: list[str] | None = None,
+    include_paths: list[str] | None = None,
+    exclude_paths: list[str] | None = None,
+    max_depth: int | None = None,
     allow_backward_crawling: bool = False,
     allow_external_content_links: bool = False,
 ) -> dict[str, Any]:
-    """
-    Execute a crawl operation using the Firecrawl API.
+    """Execute a crawl operation using the Firecrawl API.
 
     Args:
         url (str): The starting URL to crawl.
@@ -137,14 +135,13 @@ def _execute_firecrawl_crawl(
 def _execute_firecrawl_map(
     url: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
-    search: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
+    search: str | None = None,
     ignore_sitemap: bool = False,
     include_subdomains: bool = False,
     limit: int = 5000,
 ) -> dict[str, Any]:
-    """
-    Execute a map operation using the Firecrawl API to get URLs from a website.
+    """Execute a map operation using the Firecrawl API to get URLs from a website.
 
     Args:
         url (str): The website URL to map.
@@ -179,17 +176,16 @@ def _execute_firecrawl_map(
 def _execute_firecrawl_search(
     query: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
     limit: int = 5,
-    tbs: Optional[str] = None,
-    filter: Optional[str] = None,
+    tbs: str | None = None,
+    filter: str | None = None,
     lang: str = "en",
     country: str = "us",
-    location: Optional[str] = None,
-    timeout: Optional[int] = None,
+    location: str | None = None,
+    timeout: int | None = None,
 ) -> dict[str, Any]:
-    """
-    Execute a search operation using the Firecrawl API.
+    """Execute a search operation using the Firecrawl API.
 
     Args:
         query (str): The search query string.
@@ -230,15 +226,14 @@ def _execute_firecrawl_search(
 def _execute_firecrawl_deep_research(
     query: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
     max_depth: int = 7,
     time_limit: int = 270,
     max_urls: int = 20,
-    analysis_prompt: Optional[str] = None,
-    system_prompt: Optional[str] = None,
+    analysis_prompt: str | None = None,
+    system_prompt: str | None = None,
 ) -> dict[str, Any]:
-    """
-    Execute a deep research operation using the Firecrawl API.
+    """Execute a deep research operation using the Firecrawl API.
 
     Args:
         query (str): The research query or topic to investigate.
@@ -269,16 +264,15 @@ def _execute_firecrawl_deep_research(
 def _firecrawl_scrape(
     url: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
-    formats: Optional[list[str]] = None,
-    include_tags: Optional[list[str]] = None,
-    exclude_tags: Optional[list[str]] = None,
-    headers: Optional[dict[str, str]] = None,
-    wait_for: Optional[int] = None,
-    timeout: Optional[int] = None,
+    firecrawl_api_url: str | None = None,
+    formats: list[str] | None = None,
+    include_tags: list[str] | None = None,
+    exclude_tags: list[str] | None = None,
+    headers: dict[str, str] | None = None,
+    wait_for: int | None = None,
+    timeout: int | None = None,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a Firecrawl scrape and format the results.
+    """Perform a Firecrawl scrape and format the results.
 
     Args:
         url (str): The URL to scrape.
@@ -324,17 +318,16 @@ def _firecrawl_scrape(
 def _firecrawl_crawl(
     url: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
     limit: int = 5,
-    formats: Optional[list[str]] = None,
-    include_paths: Optional[list[str]] = None,
-    exclude_paths: Optional[list[str]] = None,
-    max_depth: Optional[int] = None,
+    formats: list[str] | None = None,
+    include_paths: list[str] | None = None,
+    exclude_paths: list[str] | None = None,
+    max_depth: int | None = None,
     allow_backward_crawling: bool = False,
     allow_external_content_links: bool = False,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a Firecrawl crawl and format the results.
+    """Perform a Firecrawl crawl and format the results.
 
     Args:
         url (str): The starting URL to crawl.
@@ -387,14 +380,13 @@ def _firecrawl_crawl(
 def _firecrawl_map(
     url: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
-    search: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
+    search: str | None = None,
     ignore_sitemap: bool = False,
     include_subdomains: bool = False,
     limit: int = 5000,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a Firecrawl map operation and format the results.
+    """Perform a Firecrawl map operation and format the results.
 
     Args:
         url (str): The website URL to map.
@@ -440,17 +432,16 @@ def _firecrawl_map(
 def _firecrawl_search(
     query: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
     limit: int = 5,
-    tbs: Optional[str] = None,
-    filter: Optional[str] = None,
+    tbs: str | None = None,
+    filter: str | None = None,
     lang: str = "en",
     country: str = "us",
-    location: Optional[str] = None,
-    timeout: Optional[int] = None,
+    location: str | None = None,
+    timeout: int | None = None,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a Firecrawl search and format the results.
+    """Perform a Firecrawl search and format the results.
 
     Args:
         query (str): The search query string.
@@ -504,15 +495,14 @@ def _firecrawl_search(
 def _firecrawl_deep_research(
     query: str,
     firecrawl_api_key: str,
-    firecrawl_api_url: Optional[str] = None,
+    firecrawl_api_url: str | None = None,
     max_depth: int = 7,
     time_limit: int = 270,
     max_urls: int = 20,
-    analysis_prompt: Optional[str] = None,
-    system_prompt: Optional[str] = None,
+    analysis_prompt: str | None = None,
+    system_prompt: str | None = None,
 ) -> dict[str, Any]:
-    """
-    Perform a Firecrawl deep research operation and format the results.
+    """Perform a Firecrawl deep research operation and format the results.
 
     Args:
         query (str): The research query or topic to investigate.
@@ -568,8 +558,7 @@ def _firecrawl_deep_research(
 
 @export_module("autogen.tools.experimental")
 class FirecrawlTool(Tool):
-    """
-    FirecrawlTool is a tool that uses the Firecrawl API to scrape, crawl, map, search, and research websites.
+    """FirecrawlTool is a tool that uses the Firecrawl API to scrape, crawl, map, search, and research websites.
 
     This tool allows agents to leverage Firecrawl for web content extraction, discovery, and research.
     It requires a Firecrawl API key, which can be provided during initialization or set as
@@ -590,12 +579,11 @@ class FirecrawlTool(Tool):
     def __init__(
         self,
         *,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        firecrawl_api_key: Optional[str] = None,
-        firecrawl_api_url: Optional[str] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        firecrawl_api_key: str | None = None,
+        firecrawl_api_url: str | None = None,
     ):
-        """
-        Initializes the FirecrawlTool.
+        """Initializes the FirecrawlTool.
 
         Args:
             llm_config (Optional[Union[LLMConfig, dict[str, Any]]]): LLM configuration. (Currently unused but kept for potential future integration).
@@ -618,17 +606,16 @@ class FirecrawlTool(Tool):
 
         def firecrawl_scrape(
             url: Annotated[str, "The URL to scrape."],
-            firecrawl_api_key: Annotated[Optional[str], Depends(on(self.firecrawl_api_key))],
-            firecrawl_api_url: Annotated[Optional[str], Depends(on(self.firecrawl_api_url))],
-            formats: Annotated[Optional[list[str]], "Output formats (e.g., ['markdown', 'html'])"] = None,
-            include_tags: Annotated[Optional[list[str]], "HTML tags to include"] = None,
-            exclude_tags: Annotated[Optional[list[str]], "HTML tags to exclude"] = None,
-            headers: Annotated[Optional[dict[str, str]], "HTTP headers to use"] = None,
-            wait_for: Annotated[Optional[int], "Time to wait for page load in milliseconds"] = None,
-            timeout: Annotated[Optional[int], "Request timeout in milliseconds"] = None,
+            firecrawl_api_key: Annotated[str | None, Depends(on(self.firecrawl_api_key))],
+            firecrawl_api_url: Annotated[str | None, Depends(on(self.firecrawl_api_url))],
+            formats: Annotated[list[str] | None, "Output formats (e.g., ['markdown', 'html'])"] = None,
+            include_tags: Annotated[list[str] | None, "HTML tags to include"] = None,
+            exclude_tags: Annotated[list[str] | None, "HTML tags to exclude"] = None,
+            headers: Annotated[dict[str, str] | None, "HTTP headers to use"] = None,
+            wait_for: Annotated[int | None, "Time to wait for page load in milliseconds"] = None,
+            timeout: Annotated[int | None, "Request timeout in milliseconds"] = None,
         ) -> list[dict[str, Any]]:
-            """
-            Scrapes a single URL and returns the content.
+            """Scrapes a single URL and returns the content.
 
             Args:
                 url: The URL to scrape.
@@ -663,18 +650,17 @@ class FirecrawlTool(Tool):
 
         def firecrawl_crawl(
             url: Annotated[str, "The starting URL to crawl."],
-            firecrawl_api_key: Annotated[Optional[str], Depends(on(self.firecrawl_api_key))],
-            firecrawl_api_url: Annotated[Optional[str], Depends(on(self.firecrawl_api_url))],
+            firecrawl_api_key: Annotated[str | None, Depends(on(self.firecrawl_api_key))],
+            firecrawl_api_url: Annotated[str | None, Depends(on(self.firecrawl_api_url))],
             limit: Annotated[int, "Maximum number of pages to crawl"] = 5,
-            formats: Annotated[Optional[list[str]], "Output formats (e.g., ['markdown', 'html'])"] = None,
-            include_paths: Annotated[Optional[list[str]], "URL patterns to include"] = None,
-            exclude_paths: Annotated[Optional[list[str]], "URL patterns to exclude"] = None,
-            max_depth: Annotated[Optional[int], "Maximum crawl depth"] = None,
-            allow_backward_crawling: Annotated[Optional[bool], "Allow crawling backward links"] = False,
-            allow_external_content_links: Annotated[Optional[bool], "Allow external links"] = False,
+            formats: Annotated[list[str] | None, "Output formats (e.g., ['markdown', 'html'])"] = None,
+            include_paths: Annotated[list[str] | None, "URL patterns to include"] = None,
+            exclude_paths: Annotated[list[str] | None, "URL patterns to exclude"] = None,
+            max_depth: Annotated[int | None, "Maximum crawl depth"] = None,
+            allow_backward_crawling: Annotated[bool | None, "Allow crawling backward links"] = False,
+            allow_external_content_links: Annotated[bool | None, "Allow external links"] = False,
         ) -> list[dict[str, Any]]:
-            """
-            Crawls a website starting from a URL and returns the content from multiple pages.
+            """Crawls a website starting from a URL and returns the content from multiple pages.
 
             Args:
                 url: The starting URL to crawl.
@@ -711,15 +697,14 @@ class FirecrawlTool(Tool):
 
         def firecrawl_map(
             url: Annotated[str, "The website URL to map."],
-            firecrawl_api_key: Annotated[Optional[str], Depends(on(self.firecrawl_api_key))],
-            firecrawl_api_url: Annotated[Optional[str], Depends(on(self.firecrawl_api_url))],
-            search: Annotated[Optional[str], "Search term to filter URLs"] = None,
-            ignore_sitemap: Annotated[Optional[bool], "Whether to ignore the sitemap"] = False,
-            include_subdomains: Annotated[Optional[bool], "Whether to include subdomains"] = False,
+            firecrawl_api_key: Annotated[str | None, Depends(on(self.firecrawl_api_key))],
+            firecrawl_api_url: Annotated[str | None, Depends(on(self.firecrawl_api_url))],
+            search: Annotated[str | None, "Search term to filter URLs"] = None,
+            ignore_sitemap: Annotated[bool | None, "Whether to ignore the sitemap"] = False,
+            include_subdomains: Annotated[bool | None, "Whether to include subdomains"] = False,
             limit: Annotated[int, "Maximum number of URLs to return"] = 5000,
         ) -> list[dict[str, Any]]:
-            """
-            Maps a website to discover URLs.
+            """Maps a website to discover URLs.
 
             Args:
                 url: The website URL to map.
@@ -750,18 +735,17 @@ class FirecrawlTool(Tool):
 
         def firecrawl_search(
             query: Annotated[str, "The search query string."],
-            firecrawl_api_key: Annotated[Optional[str], Depends(on(self.firecrawl_api_key))],
-            firecrawl_api_url: Annotated[Optional[str], Depends(on(self.firecrawl_api_url))],
+            firecrawl_api_key: Annotated[str | None, Depends(on(self.firecrawl_api_key))],
+            firecrawl_api_url: Annotated[str | None, Depends(on(self.firecrawl_api_url))],
             limit: Annotated[int, "Maximum number of results to return"] = 5,
-            tbs: Annotated[Optional[str], "Time filter (e.g., 'qdr:d' for past day)"] = None,
-            filter: Annotated[Optional[str], "Custom result filter"] = None,
-            lang: Annotated[Optional[str], "Language code"] = "en",
-            country: Annotated[Optional[str], "Country code"] = "us",
-            location: Annotated[Optional[str], "Geo-targeting location"] = None,
-            timeout: Annotated[Optional[int], "Request timeout in milliseconds"] = None,
+            tbs: Annotated[str | None, "Time filter (e.g., 'qdr:d' for past day)"] = None,
+            filter: Annotated[str | None, "Custom result filter"] = None,
+            lang: Annotated[str | None, "Language code"] = "en",
+            country: Annotated[str | None, "Country code"] = "us",
+            location: Annotated[str | None, "Geo-targeting location"] = None,
+            timeout: Annotated[int | None, "Request timeout in milliseconds"] = None,
         ) -> list[dict[str, Any]]:
-            """
-            Executes a search operation using the Firecrawl API.
+            """Executes a search operation using the Firecrawl API.
 
             Args:
                 query: The search query string.
@@ -798,16 +782,15 @@ class FirecrawlTool(Tool):
 
         def firecrawl_deep_research(
             query: Annotated[str, "The research query or topic to investigate."],
-            firecrawl_api_key: Annotated[Optional[str], Depends(on(self.firecrawl_api_key))],
-            firecrawl_api_url: Annotated[Optional[str], Depends(on(self.firecrawl_api_url))],
+            firecrawl_api_key: Annotated[str | None, Depends(on(self.firecrawl_api_key))],
+            firecrawl_api_url: Annotated[str | None, Depends(on(self.firecrawl_api_url))],
             max_depth: Annotated[int, "Maximum depth of research exploration"] = 7,
             time_limit: Annotated[int, "Time limit in seconds for research"] = 270,
             max_urls: Annotated[int, "Maximum number of URLs to process"] = 20,
-            analysis_prompt: Annotated[Optional[str], "Custom prompt for analysis"] = None,
-            system_prompt: Annotated[Optional[str], "Custom system prompt"] = None,
+            analysis_prompt: Annotated[str | None, "Custom prompt for analysis"] = None,
+            system_prompt: Annotated[str | None, "Custom system prompt"] = None,
         ) -> dict[str, Any]:
-            """
-            Executes a deep research operation using the Firecrawl API.
+            """Executes a deep research operation using the Firecrawl API.
 
             Args:
                 query: The research query or topic to investigate.

autogen/tools/experimental/google/authentication/credentials_local_provider.py

@@ -25,7 +25,7 @@ class GoogleCredentialsLocalProvider(GoogleCredentialsProvider):
         self,
         client_secret_file: str,
         scopes: list[str],  # e.g. ['https://www.googleapis.com/auth/drive/readonly']
-        token_file: Optional[str] = None,
+        token_file: str | None = None,
         port: int = 8080,
     ) -> None:
         """A Google credentials provider that gets the credentials locally.

autogen/tools/experimental/google/drive/drive_functions.py

@@ -4,7 +4,7 @@
 
 import io
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from .....import_utils import optional_import_block, require_optional_import
 from ..model import GoogleFileInfo
@@ -25,7 +25,7 @@ __all__ = [
     ],
     "google-api",
 )
-def list_files_and_folders(service: Any, page_size: int, folder_id: Optional[str]) -> list[GoogleFileInfo]:
+def list_files_and_folders(service: Any, page_size: int, folder_id: str | None) -> list[GoogleFileInfo]:
     kwargs = {
         "pageSize": page_size,
         "fields": "nextPageToken, files(id, name, mimeType)",
@@ -40,7 +40,7 @@ def list_files_and_folders(service: Any, page_size: int, folder_id: Optional[str
     return result
 
 
-def _get_file_extension(mime_type: str) -> Optional[str]:
+def _get_file_extension(mime_type: str) -> str | None:
     """Returns the correct file extension for a given MIME type."""
     mime_extensions = {
         "application/vnd.google-apps.document": "docx",  # Google Docs → Word
@@ -70,7 +70,7 @@ def download_file(
     file_name: str,
     mime_type: str,
     download_folder: Path,
-    subfolder_path: Optional[str] = None,
+    subfolder_path: str | None = None,
 ) -> str:
     """Download or export file based on its MIME type, optionally saving to a subfolder."""
     file_extension = _get_file_extension(mime_type)

autogen/tools/experimental/google/drive/toolkit.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from pathlib import Path
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal
 
 from .....doc_utils import export_module
 from .....import_utils import optional_import_block
@@ -29,8 +29,8 @@ class GoogleDriveToolkit(Toolkit, GoogleToolkitProtocol):
         self,
         *,
         credentials: "Credentials",
-        download_folder: Union[Path, str],
-        exclude: Optional[list[Literal["list_drive_files_and_folders", "download_file_from_drive"]]] = None,
+        download_folder: Path | str,
+        exclude: list[Literal["list_drive_files_and_folders", "download_file_from_drive"]] | None = None,
         api_version: str = "v3",
     ) -> None:
         """Initialize the Google Drive tool map.
@@ -51,7 +51,7 @@ class GoogleDriveToolkit(Toolkit, GoogleToolkitProtocol):
         def list_drive_files_and_folders(
             page_size: Annotated[int, "The number of files to list per page."] = 10,
             folder_id: Annotated[
-                Optional[str],
+                str | None,
                 "The ID of the folder to list files from. If not provided, lists all files in the root folder.",
             ] = None,
         ) -> list[GoogleFileInfo]:
@@ -61,7 +61,7 @@ class GoogleDriveToolkit(Toolkit, GoogleToolkitProtocol):
         def download_file_from_drive(
             file_info: Annotated[GoogleFileInfo, "The file info to download."],
             subfolder_path: Annotated[
-                Optional[str],
+                str | None,
                 "The subfolder path to save the file in. If not provided, saves in the main download folder.",
             ] = None,
         ) -> str:

autogen/tools/experimental/google_search/google_search.py

@@ -4,7 +4,7 @@
 
 
 import logging
-from typing import Annotated, Any, Optional
+from typing import Annotated, Any
 
 from ....doc_utils import export_module
 from ....import_utils import optional_import_block, require_optional_import
@@ -49,8 +49,8 @@ class GoogleSearchTool(Tool):
     def __init__(
         self,
         *,
-        search_api_key: Optional[str] = None,
-        search_engine_id: Optional[str] = None,
+        search_api_key: str | None = None,
+        search_engine_id: str | None = None,
         use_internal_llm_tool_if_available: bool = True,
     ):
         """GoogleSearchTool is a tool that uses the Google Search API to perform a search.
@@ -74,8 +74,8 @@ class GoogleSearchTool(Tool):
 
         def google_search(
             query: Annotated[str, "The search query."],
-            search_api_key: Annotated[Optional[str], Depends(on(search_api_key))],
-            search_engine_id: Annotated[Optional[str], Depends(on(search_engine_id))],
+            search_api_key: Annotated[str | None, Depends(on(search_api_key))],
+            search_engine_id: Annotated[str | None, Depends(on(search_engine_id))],
             num_results: Annotated[int, "The number of results to return."] = 10,
         ) -> list[dict[str, Any]]:
             if search_api_key is None or search_engine_id is None:

autogen/tools/experimental/google_search/youtube_search.py

@@ -4,7 +4,7 @@
 
 
 import logging
-from typing import Annotated, Any, Dict, List, Optional
+from typing import Annotated, Any
 
 from ....doc_utils import export_module
 from ....import_utils import optional_import_block, require_optional_import
@@ -48,7 +48,7 @@ def _execute_search_query(query: str, youtube_api_key: str, max_results: int) ->
     ["googleapiclient"],
     "google-search",
 )
-def _get_video_details(video_ids: List[str], youtube_api_key: str) -> Any:
+def _get_video_details(video_ids: list[str], youtube_api_key: str) -> Any:
     """Get detailed information about specific YouTube videos.
 
     Args:
@@ -79,7 +79,7 @@ def _youtube_search(
     youtube_api_key: str,
     max_results: int,
     include_video_details: bool = True,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Search YouTube videos based on a query.
 
     Args:
@@ -140,7 +140,7 @@ class YoutubeSearchTool(Tool):
     def __init__(
         self,
         *,
-        youtube_api_key: Optional[str] = None,
+        youtube_api_key: str | None = None,
     ):
         """Initialize a YouTube search tool.
 
@@ -157,7 +157,7 @@ class YoutubeSearchTool(Tool):
             youtube_api_key: Annotated[str, Depends(on(youtube_api_key))],
             max_results: Annotated[int, "The maximum number of results to return."] = 5,
             include_video_details: Annotated[bool, "Whether to include detailed video information."] = True,
-        ) -> List[Dict[str, Any]]:
+        ) -> list[dict[str, Any]]:
             """Search for YouTube videos based on a query.
 
             Args:

autogen/tools/experimental/messageplatform/discord/discord.py

@@ -4,7 +4,7 @@
 
 import asyncio
 from datetime import datetime, timezone
-from typing import Annotated, Any, Union
+from typing import Annotated, Any
 
 from .....doc_utils import export_module
 from .....import_utils import optional_import_block, require_optional_import
@@ -26,8 +26,7 @@ class DiscordSendTool(Tool):
     """Sends a message to a Discord channel."""
 
     def __init__(self, *, bot_token: str, channel_name: str, guild_name: str) -> None:
-        """
-        Initialize the DiscordSendTool.
+        """Initialize the DiscordSendTool.
 
         Args:
             bot_token: The bot token to use for sending messages.
@@ -42,8 +41,7 @@ class DiscordSendTool(Tool):
             guild_name: Annotated[str, Depends(on(guild_name))],
             channel_name: Annotated[str, Depends(on(channel_name))],
         ) -> Any:
-            """
-            Sends a message to a Discord channel.
+            """Sends a message to a Discord channel.
 
             Args:
                 message: The message to send to the channel.
@@ -123,8 +121,7 @@ class DiscordRetrieveTool(Tool):
     """Retrieves messages from a Discord channel."""
 
     def __init__(self, *, bot_token: str, channel_name: str, guild_name: str) -> None:
-        """
-        Initialize the DiscordRetrieveTool.
+        """Initialize the DiscordRetrieveTool.
 
         Args:
             bot_token: The bot token to use for retrieving messages.
@@ -137,15 +134,14 @@ class DiscordRetrieveTool(Tool):
             guild_name: Annotated[str, Depends(on(guild_name))],
             channel_name: Annotated[str, Depends(on(channel_name))],
             messages_since: Annotated[
-                Union[str, None],
+                str | None,
                 "Date to retrieve messages from (ISO format) OR Discord snowflake ID. If None, retrieves latest messages.",
             ] = None,
             maximum_messages: Annotated[
-                Union[int, None], "Maximum number of messages to retrieve. If None, retrieves all messages since date."
+                int | None, "Maximum number of messages to retrieve. If None, retrieves all messages since date."
             ] = None,
         ) -> Any:
-            """
-            Retrieves messages from a Discord channel.
+            """Retrieves messages from a Discord channel.
 
             Args:
                 bot_token: The bot token to use for Discord. (uses dependency injection)
@@ -162,7 +158,7 @@ class DiscordRetrieveTool(Tool):
             client = Client(intents=intents)
             result_future: asyncio.Future[list[dict[str, Any]]] = asyncio.Future()
 
-            messages_since_date: Union[str, None] = None
+            messages_since_date: str | None = None
             if messages_since is not None:
                 if DiscordRetrieveTool._is_snowflake(messages_since):
                     messages_since_date = DiscordRetrieveTool._snowflake_to_iso(messages_since)