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

autogen/tools/experimental/messageplatform/slack/slack.py

@@ -4,7 +4,7 @@
 
 import asyncio
 from datetime import datetime, timedelta
-from typing import Annotated, Any, Optional, Tuple, 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 SlackSendTool(Tool):
     """Sends a message to a Slack channel."""
 
     def __init__(self, *, bot_token: str, channel_id: str) -> None:
-        """
-        Initialize the SlackSendTool.
+        """Initialize the SlackSendTool.
 
         Args:
             bot_token: Bot User OAuth Token starting with "xoxb-".
@@ -40,8 +39,7 @@ class SlackSendTool(Tool):
             bot_token: Annotated[str, Depends(on(bot_token))],
             channel_id: Annotated[str, Depends(on(channel_id))],
         ) -> Any:
-            """
-            Sends a message to a Slack channel.
+            """Sends a message to a Slack channel.
 
             Args:
                 message: The message to send to the channel.
@@ -93,8 +91,7 @@ class SlackRetrieveTool(Tool):
     """Retrieves messages from a Slack channel."""
 
     def __init__(self, *, bot_token: str, channel_id: str) -> None:
-        """
-        Initialize the SlackRetrieveTool.
+        """Initialize the SlackRetrieveTool.
 
         Args:
             bot_token: Bot User OAuth Token starting with "xoxb-".
@@ -105,15 +102,14 @@ class SlackRetrieveTool(Tool):
             bot_token: Annotated[str, Depends(on(bot_token))],
             channel_id: Annotated[str, Depends(on(channel_id))],
             messages_since: Annotated[
-                Union[str, None],
+                str | None,
                 "Date to retrieve messages from (ISO format) OR Slack message 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)
@@ -198,8 +194,7 @@ class SlackRetrieveRepliesTool(Tool):
     """Retrieves replies to a specific Slack message from both threads and the channel."""
 
     def __init__(self, *, bot_token: str, channel_id: str) -> None:
-        """
-        Initialize the SlackRetrieveRepliesTool.
+        """Initialize the SlackRetrieveRepliesTool.
 
         Args:
             bot_token: Bot User OAuth Token starting with "xoxb-".
@@ -211,7 +206,7 @@ class SlackRetrieveRepliesTool(Tool):
             bot_token: Annotated[str, Depends(on(bot_token))],
             channel_id: Annotated[str, Depends(on(channel_id))],
             min_replies: Annotated[
-                Optional[int],
+                int | None,
                 "Minimum number of replies to wait for before returning (thread + channel). If None, returns immediately.",
             ] = None,
             timeout_seconds: Annotated[
@@ -222,8 +217,7 @@ class SlackRetrieveRepliesTool(Tool):
                 bool, "Whether to include messages in the channel after the original message."
             ] = True,
         ) -> Any:
-            """
-            Retrieves replies to a specific Slack message, from both threads and the main channel.
+            """Retrieves replies to a specific Slack message, from both threads and the main channel.
 
             Args:
                 message_ts: The timestamp (ts) identifier of the parent message.
@@ -238,7 +232,7 @@ class SlackRetrieveRepliesTool(Tool):
                 web_client = WebClient(token=bot_token)
 
                 # Function to get current thread replies
-                async def get_thread_replies() -> tuple[Optional[list[dict[str, Any]]], Optional[str]]:
+                async def get_thread_replies() -> tuple[list[dict[str, Any]] | None, str | None]:
                     try:
                         response = web_client.conversations_replies(
                             channel=channel_id,
@@ -258,7 +252,7 @@ class SlackRetrieveRepliesTool(Tool):
                         return None, f"Thread reply retrieval failed, exception: {e}"
 
                 # Function to get messages in the channel after the original message
-                async def get_channel_messages() -> Tuple[Optional[list[dict[str, Any]]], Optional[str]]:
+                async def get_channel_messages() -> tuple[list[dict[str, Any]] | None, str | None]:
                     try:
                         response = web_client.conversations_history(
                             channel=channel_id,
@@ -286,8 +280,8 @@ class SlackRetrieveRepliesTool(Tool):
                         return None, f"Channel message retrieval failed, exception: {e}"
 
                 # Function to get all replies (both thread and channel)
-                async def get_all_replies() -> Tuple[
-                    Optional[list[dict[str, Any]]], Optional[list[dict[str, Any]]], Optional[str]
+                async def get_all_replies() -> tuple[
+                    list[dict[str, Any]] | None, list[dict[str, Any]] | None, str | None
                 ]:
                     thread_replies, thread_error = await get_thread_replies()
                     if thread_error:

autogen/tools/experimental/messageplatform/telegram/telegram.py

@@ -92,8 +92,7 @@ class TelegramSendTool(BaseTelegramTool, Tool):
     """Sends a message to a Telegram channel, group, or user."""
 
     def __init__(self, *, api_id: str, api_hash: str, chat_id: str) -> None:
-        """
-        Initialize the TelegramSendTool.
+        """Initialize the TelegramSendTool.
 
         Args:
             api_id: Telegram API ID from https://my.telegram.org/apps.
@@ -106,8 +105,7 @@ class TelegramSendTool(BaseTelegramTool, Tool):
             message: Annotated[str, "Message to send to the chat."],
             chat_id: Annotated[str, Depends(on(chat_id))],
         ) -> Any:
-            """
-            Sends a message to a Telegram chat.
+            """Sends a message to a Telegram chat.
 
             Args:
                 message: The message to send.
@@ -124,7 +122,7 @@ class TelegramSendTool(BaseTelegramTool, Tool):
                             message[i : i + (MAX_MESSAGE_LENGTH - 1)]
                             for i in range(0, len(message), (MAX_MESSAGE_LENGTH - 1))
                         ]
-                        first_message: Union[Message, None] = None  # type: ignore[no-any-unimported]
+                        first_message: Message | None = None  # type: ignore[no-any-unimported]
 
                         for i, chunk in enumerate(chunks):
                             sent = await client.send_message(
@@ -163,8 +161,7 @@ class TelegramRetrieveTool(BaseTelegramTool, Tool):
     """Retrieves messages from a Telegram channel."""
 
     def __init__(self, *, api_id: str, api_hash: str, chat_id: str) -> None:
-        """
-        Initialize the TelegramRetrieveTool.
+        """Initialize the TelegramRetrieveTool.
 
         Args:
             api_id: Telegram API ID from https://my.telegram.org/apps.
@@ -177,16 +174,15 @@ class TelegramRetrieveTool(BaseTelegramTool, Tool):
         async def telegram_retrieve_messages(
             chat_id: Annotated[str, Depends(on(chat_id))],
             messages_since: Annotated[
-                Union[str, None],
+                str | None,
                 "Date to retrieve messages from (ISO format) OR message 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,
-            search: Annotated[Union[str, None], "Optional string to search for in messages."] = None,
+            search: Annotated[str | None, "Optional string to search for in messages."] = None,
         ) -> Any:
-            """
-            Retrieves messages from a Telegram chat.
+            """Retrieves messages from a Telegram chat.
 
             Args:
                 chat_id: The ID of the chat. (uses dependency injection)

autogen/tools/experimental/perplexity/perplexity_search.py

@@ -1,5 +1,4 @@
-"""
-Module: perplexity_search_tool
+"""Module: perplexity_search_tool
 Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
 SPDX-License-Identifier: Apache-2.0
 
@@ -9,7 +8,7 @@ It defines data models for responses and a tool for executing web and conversati
 
 import json
 import os
-from typing import Any, Optional, Union
+from typing import Any
 
 import requests
 from pydantic import BaseModel, ValidationError
@@ -18,8 +17,7 @@ from autogen.tools import Tool
 
 
 class Message(BaseModel):
-    """
-    Represents a message in the chat conversation.
+    """Represents a message in the chat conversation.
 
     Attributes:
         role (str): The role of the message sender (e.g., "system", "user").
@@ -31,8 +29,7 @@ class Message(BaseModel):
 
 
 class Usage(BaseModel):
-    """
-    Model representing token usage details.
+    """Model representing token usage details.
 
     Attributes:
         prompt_tokens (int): The number of tokens used for the prompt.
@@ -48,8 +45,7 @@ class Usage(BaseModel):
 
 
 class Choice(BaseModel):
-    """
-    Represents one choice in the response from the Perplexity API.
+    """Represents one choice in the response from the Perplexity API.
 
     Attributes:
         index (int): The index of this choice.
@@ -63,8 +59,7 @@ class Choice(BaseModel):
 
 
 class PerplexityChatCompletionResponse(BaseModel):
-    """
-    Represents the full chat completion response from the Perplexity API.
+    """Represents the full chat completion response from the Perplexity API.
 
     Attributes:
         id (str): Unique identifier for the response.
@@ -86,8 +81,7 @@ class PerplexityChatCompletionResponse(BaseModel):
 
 
 class SearchResponse(BaseModel):
-    """
-    Represents the response from a search query.
+    """Represents the response from a search query.
 
     Attributes:
         content (Optional[str]): The textual content returned from the search.
@@ -95,14 +89,13 @@ class SearchResponse(BaseModel):
         error (Optional[str]): An error message if the search failed.
     """
 
-    content: Union[str, None]
-    citations: Union[list[str], None]
-    error: Union[str, None]
+    content: str | None
+    citations: list[str] | None
+    error: str | None
 
 
 class PerplexitySearchTool(Tool):
-    """
-    Tool for interacting with the Perplexity AI search API.
+    """Tool for interacting with the Perplexity AI search API.
 
     This tool uses the Perplexity API to perform web search, news search,
     and conversational search, returning concise and precise responses.
@@ -118,12 +111,11 @@ class PerplexitySearchTool(Tool):
     def __init__(
         self,
         model: str = "sonar",
-        api_key: Optional[str] = None,
+        api_key: str | None = None,
         max_tokens: int = 1000,
-        search_domain_filter: Optional[list[str]] = None,
+        search_domain_filter: list[str] | None = None,
     ):
-        """
-        Initializes a new instance of the PerplexitySearchTool.
+        """Initializes a new instance of the PerplexitySearchTool.
 
         Args:
             model (str, optional): The model to use. Defaults to "sonar".
@@ -150,10 +142,9 @@ class PerplexitySearchTool(Tool):
 
     @staticmethod
     def _validate_tool_config(
-        model: str, api_key: Union[str, None], max_tokens: int, search_domain_filter: Union[list[str], None]
+        model: str, api_key: str | None, max_tokens: int, search_domain_filter: list[str] | None
     ) -> None:
-        """
-        Validates the configuration parameters for the search tool.
+        """Validates the configuration parameters for the search tool.
 
         Args:
             model (str): The model to use.
@@ -175,8 +166,7 @@ class PerplexitySearchTool(Tool):
             raise ValueError("search_domain_filter must be a list")
 
     def _execute_query(self, payload: dict[str, Any]) -> "PerplexityChatCompletionResponse":
-        """
-        Executes a query by sending a POST request to the Perplexity API.
+        """Executes a query by sending a POST request to the Perplexity API.
 
         Args:
             payload (dict[str, Any]): The payload to send in the API request.
@@ -223,8 +213,7 @@ class PerplexitySearchTool(Tool):
         return perp_resp
 
     def search(self, query: str) -> "SearchResponse":
-        """
-        Perform a search query using the Perplexity AI API.
+        """Perform a search query using the Perplexity AI API.
 
         Constructs the payload, executes the query, and parses the response to return
         a concise search result along with any provided citations.

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(