ag2 0.9.7__py3-none-any.whl → 0.9.9__py3-none-any.whl

autogen/tools/experimental/browser_use/browser_use.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Annotated, Any, Optional, Union
+from typing import Annotated, Any, Optional
 
 from pydantic import BaseModel, field_validator
 
@@ -32,11 +32,11 @@ class ExtractedContent(BaseModel):
     """
 
     content: str
-    url: Optional[str]
+    url: str | None
 
     @field_validator("url")
     @classmethod
-    def check_url(cls, v: str) -> Optional[str]:
+    def check_url(cls, v: str) -> str | None:
         """Check if the URL is about:blank and return None if it is.
 
         Args:
@@ -57,7 +57,7 @@ class BrowserUseResult(BaseModel):
     """
 
     extracted_content: list[ExtractedContent]
-    final_result: Optional[str]
+    final_result: str | None
 
 
 @require_optional_import(
@@ -78,10 +78,10 @@ class BrowserUseTool(Tool):
     def __init__(  # type: ignore[no-any-unimported]
         self,
         *,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
         browser: Optional["Browser"] = None,
-        agent_kwargs: Optional[dict[str, Any]] = None,
-        browser_config: Optional[dict[str, Any]] = None,
+        agent_kwargs: dict[str, Any] | None = None,
+        browser_config: dict[str, Any] | None = None,
     ):
         """Use the browser to perform a task.
 
@@ -104,8 +104,8 @@ class BrowserUseTool(Tool):
 
         async def browser_use(  # type: ignore[no-any-unimported]
             task: Annotated[str, "The task to perform."],
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
-            browser: Annotated[Optional[Browser], Depends(on(browser))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
+            browser: Annotated[Browser | None, Depends(on(browser))],
             agent_kwargs: Annotated[dict[str, Any], Depends(on(agent_kwargs))],
             browser_config: Annotated[dict[str, Any], Depends(on(browser_config))],
         ) -> BrowserUseResult:
@@ -145,7 +145,7 @@ class BrowserUseTool(Tool):
         )
 
     @staticmethod
-    def _get_controller(llm_config: Union[LLMConfig, dict[str, Any]]) -> Any:
+    def _get_controller(llm_config: LLMConfig | dict[str, Any]) -> Any:
         response_format = (
             llm_config["config_list"][0].get("response_format", None)
             if "config_list" in llm_config

autogen/tools/experimental/code_execution/python_code_execution.py

@@ -4,7 +4,7 @@
 
 import os
 import tempfile
-from typing import Annotated, Any, Optional
+from typing import Annotated, Any
 
 from pydantic import BaseModel, Field
 
@@ -24,11 +24,10 @@ class PythonCodeExecutionTool(Tool):
         self,
         *,
         timeout: int = 30,
-        working_directory: Optional[WorkingDirectory] = None,
-        python_environment: Optional[PythonEnvironment] = None,
+        working_directory: WorkingDirectory | None = None,
+        python_environment: PythonEnvironment | None = None,
     ) -> None:
-        """
-        Initialize the PythonCodeExecutionTool.
+        """Initialize the PythonCodeExecutionTool.
 
         **CAUTION**: If provided a local environment, this tool will execute code in your local environment, which can be dangerous if the code is untrusted.
 
@@ -56,8 +55,7 @@ class PythonCodeExecutionTool(Tool):
         async def execute_python_code(
             code_execution_request: Annotated[CodeExecutionRequest, "Python code and the libraries required"],
         ) -> dict[str, Any]:
-            """
-            Executes Python code in the attached environment and returns the result.
+            """Executes Python code in the attached environment and returns the result.
 
             Args:
                 code_execution_request (CodeExecutionRequest): The Python code and libraries to execute

autogen/tools/experimental/crawl4ai/crawl4ai.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Annotated, Any, Optional, Union
+from typing import Annotated, Any, Optional
 
 from pydantic import BaseModel
 
@@ -23,18 +23,15 @@ __all__ = ["Crawl4AITool"]
 @require_optional_import(["crawl4ai"], "crawl4ai")
 @export_module("autogen.tools.experimental")
 class Crawl4AITool(Tool):
-    """
-    Crawl a website and extract information using the crawl4ai library.
-    """
+    """Crawl a website and extract information using the crawl4ai library."""
 
     def __init__(
         self,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        extraction_model: Optional[type[BaseModel]] = None,
-        llm_strategy_kwargs: Optional[dict[str, Any]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        extraction_model: type[BaseModel] | None = None,
+        llm_strategy_kwargs: dict[str, Any] | None = None,
     ) -> None:
-        """
-        Initialize the Crawl4AITool.
+        """Initialize the Crawl4AITool.
 
         Args:
             llm_config: The config dictionary for the LLM model. If None, the tool will run without LLM.
@@ -70,8 +67,8 @@ class Crawl4AITool(Tool):
             url: Annotated[str, "The url to crawl and extract information from."],
             instruction: Annotated[str, "The instruction to provide on how and what to extract."],
             llm_config: Annotated[Any, Depends(on(llm_config))],
-            llm_strategy_kwargs: Annotated[Optional[dict[str, Any]], Depends(on(llm_strategy_kwargs))],
-            extraction_model: Annotated[Optional[type[BaseModel]], Depends(on(extraction_model))],
+            llm_strategy_kwargs: Annotated[dict[str, Any] | None, Depends(on(llm_strategy_kwargs))],
+            extraction_model: Annotated[type[BaseModel] | None, Depends(on(extraction_model))],
         ) -> Any:
             browser_cfg = BrowserConfig(headless=True)
             crawl_config = Crawl4AITool._get_crawl_config(
@@ -90,7 +87,7 @@ class Crawl4AITool(Tool):
         )
 
     @staticmethod
-    def _validate_llm_strategy_kwargs(llm_strategy_kwargs: Optional[dict[str, Any]], llm_config_provided: bool) -> None:
+    def _validate_llm_strategy_kwargs(llm_strategy_kwargs: dict[str, Any] | None, llm_config_provided: bool) -> None:
         if not llm_strategy_kwargs:
             return
 
@@ -120,10 +117,10 @@ class Crawl4AITool(Tool):
 
     @staticmethod
     def _get_crawl_config(  # type: ignore[no-any-unimported]
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         instruction: str,
-        llm_strategy_kwargs: Optional[dict[str, Any]] = None,
-        extraction_model: Optional[type[BaseModel]] = None,
+        llm_strategy_kwargs: dict[str, Any] | None = None,
+        extraction_model: type[BaseModel] | None = None,
     ) -> "CrawlerRunConfig":
         lite_llm_config = LiteLLmConfigFactory.create_lite_llm_config(llm_config)
 

autogen/tools/experimental/deep_research/deep_research.py

@@ -3,7 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import copy
-from typing import Annotated, Any, Callable, Union
+from collections.abc import Callable
+from typing import Annotated, Any
 
 from pydantic import BaseModel, Field
 
@@ -77,7 +78,7 @@ class DeepResearchTool(Tool):
 
     def __init__(
         self,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         max_web_steps: int = 30,
     ):
         """Initialize the DeepResearchTool.
@@ -117,7 +118,7 @@ class DeepResearchTool(Tool):
 
         def delegate_research_task(
             task: Annotated[str, "The task to perform a research on."],
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
             """Delegate a research task to the agent.
@@ -165,11 +166,11 @@ class DeepResearchTool(Tool):
 
     @staticmethod
     def _get_split_question_and_answer_subquestions(
-        llm_config: Union[LLMConfig, dict[str, Any]], max_web_steps: int
+        llm_config: LLMConfig | dict[str, Any], max_web_steps: int
     ) -> Callable[..., Any]:
         def split_question_and_answer_subquestions(
             question: Annotated[str, "The question to split and answer."],
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
             decomposition_agent = ConversableAgent(
@@ -233,7 +234,7 @@ class DeepResearchTool(Tool):
 
     @staticmethod
     def _get_generate_subquestions(
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         max_web_steps: int,
     ) -> Callable[..., str]:
         """Get the generate_subquestions method.
@@ -248,7 +249,7 @@ class DeepResearchTool(Tool):
 
         def generate_subquestions(
             task: Task,
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
             if not task.subquestions:
@@ -270,7 +271,7 @@ class DeepResearchTool(Tool):
     @staticmethod
     def _answer_question(
         question: str,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         max_web_steps: int,
     ) -> str:
         from ....agents.experimental.websurfer import WebSurferAgent

autogen/tools/experimental/duckduckgo/duckduckgo_search.py

@@ -21,8 +21,7 @@ def _execute_duckduckgo_query(
     query: str,
     num_results: int = 5,
 ) -> list[dict[str, Any]]:
-    """
-    Execute a search query using the DuckDuckGo Search API.
+    """Execute a search query using the DuckDuckGo Search API.
 
     Args:
         query (str): The search query string.
@@ -45,8 +44,7 @@ def _duckduckgo_search(
     query: str,
     num_results: int = 5,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a DuckDuckGo search and format the results.
+    """Perform a DuckDuckGo search and format the results.
 
     This function takes search parameters, executes the query using `_execute_duckduckgo_query`,
     and formats the results into a list of dictionaries containing title, link, and snippet.
@@ -71,24 +69,20 @@ def _duckduckgo_search(
 
 @export_module("autogen.tools.experimental")
 class DuckDuckGoSearchTool(Tool):
-    """
-    DuckDuckGoSearchTool is a tool that uses DuckDuckGo to perform a search.
+    """DuckDuckGoSearchTool is a tool that uses DuckDuckGo to perform a search.
 
     This tool allows agents to leverage the DuckDuckGo search engine for information retrieval.
     DuckDuckGo does not require an API key, making it easy to use.
     """
 
     def __init__(self) -> None:
-        """
-        Initializes the DuckDuckGoSearchTool.
-        """
+        """Initializes the DuckDuckGoSearchTool."""
 
         def duckduckgo_search(
             query: Annotated[str, "The search query."],
             num_results: Annotated[int, "The number of results to return."] = 5,
         ) -> list[dict[str, Any]]:
-            """
-            Performs a search using the DuckDuckGo Search API and returns formatted results.
+            """Performs a search using the DuckDuckGo Search API and returns formatted results.
 
             Args:
                 query: The search query string.

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.