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

autogen/tools/experimental/reliable/reliable.py

@@ -14,7 +14,8 @@ import json
 import logging
 import time
 import warnings
-from typing import Annotated, Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from collections.abc import Callable
+from typing import Annotated, Any
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
 
@@ -61,13 +62,13 @@ class ExecutionAttempt(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
     timestamp: float = Field(default_factory=time.time)
-    attempt_args: List[Any] = Field(default_factory=list)
-    attempt_kwargs: Dict[str, Any] = Field(default_factory=dict)
-    hypothesis: Optional[str] = None
-    error: Optional[str] = None
-    result_data: Optional[Any] = None
-    result_str: Optional[str] = None
-    validation: Optional[ValidationResult] = None
+    attempt_args: list[Any] = Field(default_factory=list)
+    attempt_kwargs: dict[str, Any] = Field(default_factory=dict)
+    hypothesis: str | None = None
+    error: str | None = None
+    result_data: Any | None = None
+    result_str: str | None = None
+    validation: ValidationResult | None = None
 
     @property
     def did_execute_successfully(self) -> bool:
@@ -87,14 +88,12 @@ class ReliableToolContext(BaseModel):
     task: str
     reliable_tool_name: str
     start_time: float = Field(default_factory=time.time)
-    dynamic_validation_input: Optional[str] = None
-    attempts: List[ExecutionAttempt] = Field(default_factory=list)
-    initial_messages: Optional[List[dict[str, Any]]] = Field(
+    dynamic_validation_input: str | None = None
+    attempts: list[ExecutionAttempt] = Field(default_factory=list)
+    initial_messages: list[dict[str, Any]] | None = Field(
         default=None, description="Initial messages provided to the tool run."
     )
-    initial_ground_truth: Optional[List[str]] = Field(
-        default=None, description="Initial ground truth strings provided."
-    )
+    initial_ground_truth: list[str] | None = Field(default=None, description="Initial ground truth strings provided.")
 
     @property
     def attempt_count(self) -> int:
@@ -102,7 +101,7 @@ class ReliableToolContext(BaseModel):
         return len(self.attempts)
 
     @property
-    def latest_attempt(self) -> Optional[ExecutionAttempt]:
+    def latest_attempt(self) -> ExecutionAttempt | None:
         """Return the most recent attempt, if any."""
         return self.attempts[-1] if self.attempts else None
 
@@ -143,8 +142,8 @@ class SuccessfulExecutionParameters(BaseModel):
     """Holds the arguments of a successful tool function execution."""
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
-    attempt_args: List[Any]
-    attempt_kwargs: Dict[str, Any]
+    attempt_args: list[Any]
+    attempt_kwargs: dict[str, Any]
 
 
 class ToolExecutionDetails(BaseModel):
@@ -153,14 +152,14 @@ class ToolExecutionDetails(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     task: str
     is_overall_successful: bool
-    failure_reason: Optional[str] = None
-    successful_parameters: Optional[SuccessfulExecutionParameters] = None
+    failure_reason: str | None = None
+    successful_parameters: SuccessfulExecutionParameters | None = None
     final_tool_context: ReliableToolContext
 
 
 def _configure_llm_for_structured_output(
-    llm_config: Optional[Union[LLMConfig, dict[str, Any]]], structured_output_type: Type[BaseModel]
-) -> Union[LLMConfig, dict[str, Any]]:  # Return type changed, False is no longer a valid return
+    llm_config: LLMConfig | dict[str, Any] | None, structured_output_type: type[BaseModel]
+) -> LLMConfig | dict[str, Any]:  # Return type changed, False is no longer a valid return
     """Configure LLM config for structured output using a Pydantic model."""
     if llm_config is None or llm_config is False:
         raise ValueError("LLMConfig cannot be None or False for structured output.")
@@ -174,7 +173,7 @@ def _configure_llm_for_structured_output(
 
     response_format_set = False
 
-    def _set_format_and_remove_conflicts(config_item: Union[LLMConfig, Dict[str, Any]]) -> None:
+    def _set_format_and_remove_conflicts(config_item: LLMConfig | dict[str, Any]) -> None:
         nonlocal response_format_set
         conflicting_keys = ["tools", "tool_choice", "functions"]
         removed_keys = []
@@ -192,7 +191,7 @@ def _configure_llm_for_structured_output(
             for key in conflicting_keys:
                 if hasattr(config_item, key) and getattr(config_item, key, None):
                     # Try setting to None or empty list/dict as appropriate
-                    default_empty: Optional[List[str]] = [] if key in ["tools", "functions"] else None
+                    default_empty: list[str] | None = [] if key in ["tools", "functions"] else None
                     setattr(config_item, key, default_empty)
                     removed_keys.append(key)
         else:
@@ -243,7 +242,7 @@ def _configure_llm_for_structured_output(
     return llm_config_obj
 
 
-def _get_last_non_empty_message_content(messages: Optional[List[dict[str, Any]]]) -> Optional[str]:
+def _get_last_non_empty_message_content(messages: list[dict[str, Any]] | None) -> str | None:
     """Get content of the last message with non-empty content."""
     if not messages:
         return None
@@ -342,7 +341,7 @@ Current Task:
 
 
 def get_validator_prompt(
-    task: str, base_validator_system_message: str, dynamic_validation_addition: Optional[str] = None
+    task: str, base_validator_system_message: str, dynamic_validation_addition: str | None = None
 ) -> str:
     """Generate the system prompt for the internal validator agent."""
     dynamic_section = (
@@ -517,7 +516,7 @@ def reliable_function_wrapper(
 class ReliableToolError(Exception):
     """Custom exception for errors during ReliableTool execution."""
 
-    def __init__(self, message: str, final_context: Optional[ReliableToolContext] = None):
+    def __init__(self, message: str, final_context: ReliableToolContext | None = None):
         super().__init__(message)
         self.final_context = final_context
 
@@ -529,19 +528,18 @@ class ReliableTool(Tool):
     def __init__(
         self,
         name: str,
-        func_or_tool: Union[Callable[..., Any], Tool],
-        runner_llm_config: Union[LLMConfig, dict[str, Any]],
-        validator_llm_config: Union[LLMConfig, dict[str, Any]],
-        description: Optional[str] = None,
+        func_or_tool: Callable[..., Any] | Tool,
+        runner_llm_config: LLMConfig | dict[str, Any],
+        validator_llm_config: LLMConfig | dict[str, Any],
+        description: str | None = None,
         system_message_addition_for_tool_calling: str = "",
         system_message_addition_for_result_validation: str = "",
         max_tool_invocations: int = 3,
         enable_dynamic_validation: bool = False,
-        messages: Optional[List[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> None:
-        """
-        A ReliableTool wraps an existing function or tool.
+        """A ReliableTool wraps an existing function or tool.
         When the ReliableTool is invoked, it kicks off an internal Group Chat where a Runner
         and Validator agent will iteratively invoke the wrapped function or tool until
         *the output of a single invocation of the original function or tool satisfies the provided validation criteria.*
@@ -703,9 +701,7 @@ class ReliableTool(Tool):
         if not is_async:
             if enable_dynamic:
 
-                def sync_entry_point_with_validation(
-                    task: str, validation_prompt_addition: Optional[str] = None
-                ) -> Any:
+                def sync_entry_point_with_validation(task: str, validation_prompt_addition: str | None = None) -> Any:
                     return self.run(task=task, validation_prompt_addition=validation_prompt_addition)
 
                 return sync_entry_point_with_validation
@@ -719,7 +715,7 @@ class ReliableTool(Tool):
             if enable_dynamic:
 
                 async def async_entry_point_with_validation(
-                    task: str, validation_prompt_addition: Optional[str] = None
+                    task: str, validation_prompt_addition: str | None = None
                 ) -> Any:
                     return await self.a_run(task=task, validation_prompt_addition=validation_prompt_addition)
 
@@ -731,9 +727,7 @@ class ReliableTool(Tool):
 
                 return async_entry_point_without_validation
 
-    def _extract_func_details(
-        self, func_or_tool: Union[Callable[..., Any], Tool]
-    ) -> Tuple[Callable[..., Any], str, str]:
+    def _extract_func_details(self, func_or_tool: Callable[..., Any] | Tool) -> tuple[Callable[..., Any], str, str]:
         default_desc_template = "Executes the '{name}' function."
         if isinstance(func_or_tool, Tool):
             func = getattr(func_or_tool, "func", None)
@@ -806,8 +800,8 @@ class ReliableTool(Tool):
         self._runner.register_hook(hookable_method="process_message_before_send", hook=self._ensure_function_call_hook)
 
     def _validator_structured_output_hook(
-        self, sender: Agent, message: Union[dict[str, Any], str], recipient: Agent, silent: bool
-    ) -> Union[dict[str, Any], str]:
+        self, sender: Agent, message: dict[str, Any] | str, recipient: Agent, silent: bool
+    ) -> dict[str, Any] | str:
         if not isinstance(message, str):
             logger.error(
                 f"Validator Hook: Expected a JSON string message from LLM, but got {type(message)}. Content: {str(message)[:200]}"
@@ -885,8 +879,8 @@ class ReliableTool(Tool):
         return final_messages
 
     def _ensure_function_call_hook(
-        self, sender: Agent, message: Union[dict[str, Any], str], recipient: Agent, silent: bool
-    ) -> Union[dict[str, Any], str]:
+        self, sender: Agent, message: dict[str, Any] | str, recipient: Agent, silent: bool
+    ) -> dict[str, Any] | str:
         if sender.name != self._runner_name:
             return message
 
@@ -941,8 +935,8 @@ class ReliableTool(Tool):
         self,
         task: str,
         initial_context_vars: ContextVariables,  # Renamed for clarity
-        dynamic_validation_str: Optional[str] = None,
-    ) -> Tuple[ChatResult, ContextVariables, Agent]:
+        dynamic_validation_str: str | None = None,
+    ) -> tuple[ChatResult, ContextVariables, Agent]:
         internal_tool_name = f"{self.INTERNAL_TOOL_NAME_PREFIX}{self._original_func_name}"
 
         # update_system_message should not fail if agent is properly initialized
@@ -1008,9 +1002,9 @@ class ReliableTool(Tool):
         self,
         task: str,
         current_context_variables: ContextVariables,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> ReliableToolContext:
         """Initializes or updates the ReliableToolContext for the current run."""
         effective_messages = copy.deepcopy(messages) if messages is not None else self._init_messages
@@ -1029,10 +1023,10 @@ class ReliableTool(Tool):
     def _process_run(
         self,
         task: str,
-        context_variables: Optional[ContextVariables] = None,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        context_variables: ContextVariables | None = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> Any:
         current_context_variables = context_variables if context_variables is not None else ContextVariables()
         if not isinstance(current_context_variables, ContextVariables):
@@ -1082,10 +1076,10 @@ class ReliableTool(Tool):
     def run(
         self,
         task: str,
-        context_variables: Optional[ContextVariables] = None,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        context_variables: ContextVariables | None = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> Any:
         if self._is_original_func_async:
             raise TypeError(f"Sync 'run()' called for async tool '{self.name}'. Use 'a_run()'.")
@@ -1100,10 +1094,10 @@ class ReliableTool(Tool):
     async def a_run(
         self,
         task: str,
-        context_variables: Optional[ContextVariables] = None,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        context_variables: ContextVariables | None = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> Any:
         if not self._is_original_func_async:
             warnings.warn(
@@ -1127,10 +1121,10 @@ class ReliableTool(Tool):
     def _process_run_with_details(
         self,
         task: str,
-        context_variables: Optional[ContextVariables] = None,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        context_variables: ContextVariables | None = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> ToolExecutionDetails:
         current_context_variables = context_variables if context_variables is not None else ContextVariables()
         if not isinstance(current_context_variables, ContextVariables):
@@ -1251,10 +1245,10 @@ class ReliableTool(Tool):
     def run_and_get_details(
         self,
         task: str,
-        context_variables: Optional[ContextVariables] = None,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        context_variables: ContextVariables | None = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> ToolExecutionDetails:
         if self._is_original_func_async:
             raise TypeError(
@@ -1272,10 +1266,10 @@ class ReliableTool(Tool):
     async def a_run_and_get_details(
         self,
         task: str,
-        context_variables: Optional[ContextVariables] = None,
-        validation_prompt_addition: Optional[str] = None,
-        messages: Optional[list[dict[str, Any]]] = None,
-        ground_truth: Optional[List[str]] = None,
+        context_variables: ContextVariables | None = None,
+        validation_prompt_addition: str | None = None,
+        messages: list[dict[str, Any]] | None = None,
+        ground_truth: list[str] | None = None,
     ) -> ToolExecutionDetails:
         if not self._is_original_func_async:
             warnings.warn(

autogen/tools/experimental/searxng/searxng_search.py

@@ -1,13 +1,12 @@
 # Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
 #
 # SPDX-License-Identifier: Apache-2.0
-"""
-SearxNG Search Tool
+"""SearxNG Search Tool
 A simple tool to perform web searches using a SearxNG instance.
 """
 
 import logging
-from typing import Annotated, Any, List, Optional
+from typing import Annotated, Any
 
 import requests
 
@@ -20,18 +19,19 @@ logger = logging.getLogger(__name__)
 def _execute_searxng_query(
     query: str,
     max_results: int = 5,
-    categories: Optional[List[str]] = None,
-    language: Optional[str] = None,
+    categories: list[str] | None = None,
+    language: str | None = None,
     base_url: str = "https://searxng.site/search",
 ) -> list[dict[str, Any]]:
-    """
-    Execute a search query using a SearxNG instance.
+    """Execute a search query using a SearxNG instance.
+
     Args:
         query (str): The search query string.
         max_results (int, optional): The maximum number of results to return. Defaults to 5.
         categories (Optional[List[str]]): List of categories to search in.
         language (Optional[str]): Language code.
         base_url (str): SearxNG instance URL.
+
     Returns:
         list[dict[str, Any]]: A list of search results from SearxNG.
     """
@@ -64,18 +64,19 @@ def _execute_searxng_query(
 def _searxng_search(
     query: str,
     max_results: int = 5,
-    categories: Optional[List[str]] = None,
-    language: Optional[str] = None,
+    categories: list[str] | None = None,
+    language: str | None = None,
     base_url: str = "https://searxng.site/search",
 ) -> list[dict[str, Any]]:
-    """
-    Perform a SearxNG search and format the results.
+    """Perform a SearxNG search and format the results.
+
     Args:
         query (str): The search query string.
         max_results (int, optional): The maximum number of results to return. Defaults to 5.
         categories (Optional[List[str]]): List of categories to search in.
         language (Optional[str]): Language code.
         base_url (str): SearxNG instance URL.
+
     Returns:
         list[dict[str, Any]]: A list of dictionaries with 'title', 'link', and 'snippet'.
     """
@@ -95,16 +96,15 @@ def _searxng_search(
 
 @export_module("autogen.tools.experimental")
 class SearxngSearchTool(Tool):
-    """
-    SearxngSearchTool is a tool that uses SearxNG to perform a search.
+    """SearxngSearchTool is a tool that uses SearxNG to perform a search.
 
     This tool allows agents to leverage the SearxNG search engine for information retrieval.
     SearxNG does not require an API key by default, making it easy to use.
     """
 
     def __init__(self, base_url: str = "https://searxng.site/search") -> None:
-        """
-        Initializes the SearxngSearchTool.
+        """Initializes the SearxngSearchTool.
+
         Args:
             base_url (str): The SearxNG instance URL.
         """
@@ -119,16 +119,17 @@ class SearxngSearchTool(Tool):
         self,
         query: Annotated[str, "The search query."],
         max_results: Annotated[int, "The number of results to return."] = 5,
-        categories: Annotated[Optional[List[str]], "List of categories to search in."] = None,
-        language: Annotated[Optional[str], "Language code (e.g., 'en-US')."] = None,
+        categories: Annotated[list[str] | None, "List of categories to search in."] = None,
+        language: Annotated[str | None, "Language code (e.g., 'en-US')."] = None,
     ) -> list[dict[str, Any]]:
-        """
-        Performs a search using the SearxNG API and returns formatted results.
+        """Performs a search using the SearxNG API and returns formatted results.
+
         Args:
             query: The search query string.
             max_results: The maximum number of results to return. Defaults to 5.
             categories: List of categories to search in.
             language: Language code.
+
         Returns:
             A list of dictionaries, each containing 'title', 'link', and 'snippet' of a search result.
         """

autogen/tools/experimental/tavily/tavily_search.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 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
@@ -30,8 +30,7 @@ def _execute_tavily_query(
     include_domains: list[str] = [],
     num_results: int = 5,
 ) -> Any:
-    """
-    Execute a search query using the Tavily API.
+    """Execute a search query using the Tavily API.
 
     Args:
         query (str): The search query string.
@@ -68,8 +67,7 @@ def _tavily_search(
     include_domains: list[str] = [],
     num_results: int = 5,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a Tavily search and format the results.
+    """Perform a Tavily search and format the results.
 
     This function takes search parameters, executes the query using `_execute_tavily_query`,
     and formats the results into a list of dictionaries containing title, link, and snippet.
@@ -107,8 +105,7 @@ def _tavily_search(
 
 @export_module("autogen.tools.experimental")
 class TavilySearchTool(Tool):
-    """
-    TavilySearchTool is a tool that uses the Tavily Search API to perform a search.
+    """TavilySearchTool is a tool that uses the Tavily Search API to perform a search.
 
     This tool allows agents to leverage the Tavily search engine for information retrieval.
     It requires a Tavily API key, which can be provided during initialization or set as
@@ -118,11 +115,8 @@ class TavilySearchTool(Tool):
         tavily_api_key (str): The API key used for authenticating with the Tavily API.
     """
 
-    def __init__(
-        self, *, llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None, tavily_api_key: Optional[str] = None
-    ):
-        """
-        Initializes the TavilySearchTool.
+    def __init__(self, *, llm_config: LLMConfig | dict[str, Any] | None = None, tavily_api_key: str | None = None):
+        """Initializes the TavilySearchTool.
 
         Args:
             llm_config (Optional[Union[LLMConfig, dict[str, Any]]]): LLM configuration. (Currently unused but kept for potential future integration).
@@ -139,15 +133,14 @@ class TavilySearchTool(Tool):
 
         def tavily_search(
             query: Annotated[str, "The search query."],
-            tavily_api_key: Annotated[Optional[str], Depends(on(self.tavily_api_key))],
-            search_depth: Annotated[Optional[str], "Either 'advanced' or 'basic'"] = "basic",
-            include_answer: Annotated[Optional[str], "Either 'advanced' or 'basic'"] = "basic",
-            include_raw_content: Annotated[Optional[bool], "Include the raw contents"] = False,
-            include_domains: Annotated[Optional[list[str]], "Specific web domains to search"] = [],
+            tavily_api_key: Annotated[str | None, Depends(on(self.tavily_api_key))],
+            search_depth: Annotated[str | None, "Either 'advanced' or 'basic'"] = "basic",
+            include_answer: Annotated[str | None, "Either 'advanced' or 'basic'"] = "basic",
+            include_raw_content: Annotated[bool | None, "Include the raw contents"] = False,
+            include_domains: Annotated[list[str] | None, "Specific web domains to search"] = [],
             num_results: Annotated[int, "The number of results to return."] = 5,
         ) -> list[dict[str, Any]]:
-            """
-            Performs a search using the Tavily API and returns formatted results.
+            """Performs a search using the Tavily API and returns formatted results.
 
             Args:
                 query: The search query string.

autogen/tools/experimental/web_search_preview/web_search_preview.py

@@ -6,7 +6,7 @@
 import copy
 import logging
 import os
-from typing import Annotated, Any, Literal, Optional, Type, Union
+from typing import Annotated, Any, Literal
 
 from pydantic import BaseModel
 
@@ -29,11 +29,11 @@ class WebSearchPreviewTool(Tool):
     def __init__(
         self,
         *,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         search_context_size: Literal["low", "medium", "high"] = "medium",
-        user_location: Optional[dict[str, str]] = None,
-        instructions: Optional[str] = None,
-        text_format: Optional[Type[BaseModel]] = None,
+        user_location: dict[str, str] | None = None,
+        instructions: str | None = None,
+        text_format: type[BaseModel] | None = None,
     ):
         """Initialize the WebSearchPreviewTool.
 
@@ -85,7 +85,7 @@ class WebSearchPreviewTool(Tool):
 
         def web_search_preview(
             query: Annotated[str, "The search query. Add all relevant context to the query."],
-        ) -> Union[str, Optional[BaseModel]]:
+        ) -> str | BaseModel | None:
             client = OpenAI()
 
             if not self.text_format:
@@ -95,7 +95,13 @@ class WebSearchPreviewTool(Tool):
                     input=query,
                     instructions=self.instructions,
                 )
-                return response.output_text
+                text = []
+                for output in response.output:
+                    if output.type == "message":
+                        for content in output.content:
+                            if content.type == "output_text":
+                                text.append(content.text)
+                return "\n".join(text)
 
             else:
                 response = client.responses.parse(

autogen/tools/experimental/wikipedia/wikipedia.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional, Union
+from typing import Any
 
 import requests
 from pydantic import BaseModel
@@ -102,7 +102,7 @@ class WikipediaClient:
         search_data = data.get("query", {}).get("search", [])
         return search_data
 
-    def get_page(self, title: str) -> Optional[Any]:
+    def get_page(self, title: str) -> Any | None:
         """Retrieve a WikipediaPage object by title.
 
         Args:
@@ -158,7 +158,7 @@ class WikipediaQueryRunTool(Tool):
             func_or_tool=self.query_run,
         )
 
-    def query_run(self, query: str) -> Union[list[str], str]:
+    def query_run(self, query: str) -> list[str] | str:
         """Search Wikipedia and return formatted page summaries.
 
         Truncates `query` to MAX_QUERY_LENGTH before searching.
@@ -194,8 +194,7 @@ class WikipediaQueryRunTool(Tool):
 
 @require_optional_import(["wikipediaapi"], "wikipedia")
 class WikipediaPageLoadTool(Tool):
-    """
-    A tool to load up to N characters of Wikipedia page content along with metadata.
+    """A tool to load up to N characters of Wikipedia page content along with metadata.
 
     This tool uses a language-specific Wikipedia client to search for relevant articles
     and returns a list of Document objects containing truncated page content and metadata
@@ -212,8 +211,7 @@ class WikipediaPageLoadTool(Tool):
     """
 
     def __init__(self, language: str = "en", top_k: int = 3, truncate: int = 4000, verbose: bool = False) -> None:
-        """
-        Initializes the WikipediaPageLoadTool with configurable language, result count, and content length.
+        """Initializes the WikipediaPageLoadTool with configurable language, result count, and content length.
 
         Args:
             language (str): The language code for the Wikipedia edition (default is "en").
@@ -240,9 +238,8 @@ class WikipediaPageLoadTool(Tool):
             func_or_tool=self.content_search,
         )
 
-    def content_search(self, query: str) -> Union[list[Document], str]:
-        """
-        Executes a Wikipedia search and returns page content plus metadata.
+    def content_search(self, query: str) -> list[Document] | str:
+        """Executes a Wikipedia search and returns page content plus metadata.
 
         Args:
             query (str): The search term to query Wikipedia.