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

autogen/agentchat/realtime/experimental/audio_adapters/twilio_audio_adapter.py

@@ -5,7 +5,7 @@
 import base64
 import json
 from logging import Logger
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .....doc_utils import export_module
 from ..realtime_events import AudioDelta, RealtimeEvent, SpeechStarted
@@ -32,7 +32,7 @@ SHOW_TIMING_MATH = False
 class TwilioAudioAdapter(RealtimeObserver):
     """Adapter for streaming audio from Twilio to OpenAI Realtime API and vice versa."""
 
-    def __init__(self, websocket: "WebSocket", *, logger: Optional[Logger] = None):
+    def __init__(self, websocket: "WebSocket", *, logger: Logger | None = None):
         """Adapter for streaming audio from Twilio to OpenAI Realtime API and vice versa.
 
         Args:
@@ -45,9 +45,9 @@ class TwilioAudioAdapter(RealtimeObserver):
         # Connection specific state
         self.stream_sid = None
         self.latest_media_timestamp = 0
-        self.last_assistant_item: Optional[str] = None
+        self.last_assistant_item: str | None = None
         self.mark_queue: list[str] = []
-        self.response_start_timestamp_twilio: Optional[int] = None
+        self.response_start_timestamp_twilio: int | None = None
 
     async def on_event(self, event: RealtimeEvent) -> None:
         """Receive events from the OpenAI Realtime API, send audio back to Twilio."""

autogen/agentchat/realtime/experimental/audio_adapters/websocket_audio_adapter.py

@@ -5,7 +5,7 @@
 import base64
 import json
 from logging import Logger
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .....doc_utils import export_module
 from ..realtime_events import AudioDelta, RealtimeEvent, SpeechStarted
@@ -29,7 +29,7 @@ SHOW_TIMING_MATH = False
 
 @export_module("autogen.agentchat.realtime.experimental")
 class WebSocketAudioAdapter(RealtimeObserver):
-    def __init__(self, websocket: "WebSocket", *, logger: Optional[Logger] = None) -> None:
+    def __init__(self, websocket: "WebSocket", *, logger: Logger | None = None) -> None:
         """Observer for handling function calls from the OpenAI Realtime API.
 
         Args:
@@ -42,9 +42,9 @@ class WebSocketAudioAdapter(RealtimeObserver):
         # Connection specific state
         self.stream_sid = None
         self.latest_media_timestamp = 0
-        self.last_assistant_item: Optional[str] = None
+        self.last_assistant_item: str | None = None
         self.mark_queue: list[str] = []
-        self.response_start_timestamp_socket: Optional[int] = None
+        self.response_start_timestamp_socket: int | None = None
 
     async def on_event(self, event: RealtimeEvent) -> None:
         """Receive events from the OpenAI Realtime API, send audio back to websocket."""

autogen/agentchat/realtime/experimental/clients/gemini/client.py

@@ -3,10 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import json
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from logging import Logger, getLogger
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from ......doc_utils import export_module
 from ......import_utils import optional_import_block, require_optional_import
@@ -41,8 +41,8 @@ class GeminiRealtimeClient(RealtimeClientBase):
     def __init__(
         self,
         *,
-        llm_config: Union[LLMConfig, dict[str, Any]],
-        logger: Optional[Logger] = None,
+        llm_config: LLMConfig | dict[str, Any],
+        logger: Logger | None = None,
     ) -> None:
         """(Experimental) Client for Gemini Realtime API.
 
@@ -54,7 +54,7 @@ class GeminiRealtimeClient(RealtimeClientBase):
         self._llm_config = llm_config
         self._logger = logger
 
-        self._connection: Optional["ClientConnection"] = None
+        self._connection: ClientConnection | None = None
         config = llm_config["config_list"][0]
 
         self._model: str = config["model"]
@@ -252,8 +252,8 @@ class GeminiRealtimeClient(RealtimeClientBase):
 
     @classmethod
     def get_factory(
-        cls, llm_config: Union[LLMConfig, dict[str, Any]], logger: Logger, **kwargs: Any
-    ) -> Optional[Callable[[], "RealtimeClientProtocol"]]:
+        cls, llm_config: LLMConfig | dict[str, Any], logger: Logger, **kwargs: Any
+    ) -> Callable[[], "RealtimeClientProtocol"] | None:
         """Create a Realtime API client.
 
         Args:

autogen/agentchat/realtime/experimental/clients/oai/base_client.py

@@ -2,10 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from logging import Logger, getLogger
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from ......doc_utils import export_module
 from ......import_utils import optional_import_block, require_optional_import
@@ -36,8 +36,8 @@ class OpenAIRealtimeClient(RealtimeClientBase):
     def __init__(
         self,
         *,
-        llm_config: Union[LLMConfig, dict[str, Any]],
-        logger: Optional[Logger] = None,
+        llm_config: LLMConfig | dict[str, Any],
+        logger: Logger | None = None,
     ) -> None:
         """(Experimental) Client for OpenAI Realtime API.
 
@@ -49,7 +49,7 @@ class OpenAIRealtimeClient(RealtimeClientBase):
         self._llm_config = llm_config
         self._logger = logger
 
-        self._connection: Optional["AsyncRealtimeConnection"] = None
+        self._connection: AsyncRealtimeConnection | None = None
 
         self.config = llm_config["config_list"][0]
         # model is passed to self._client.beta.realtime.connect function later
@@ -57,7 +57,7 @@ class OpenAIRealtimeClient(RealtimeClientBase):
         self._voice: str = self.config.get("voice", "alloy")
         self._temperature: float = llm_config.get("temperature", 0.8)  # type: ignore[union-attr]
 
-        self._client: Optional["AsyncOpenAI"] = None
+        self._client: AsyncOpenAI | None = None
 
     @property
     def logger(self) -> Logger:
@@ -198,8 +198,8 @@ class OpenAIRealtimeClient(RealtimeClientBase):
 
     @classmethod
     def get_factory(
-        cls, llm_config: Union[LLMConfig, dict[str, Any]], logger: Logger, **kwargs: Any
-    ) -> Optional[Callable[[], "RealtimeClientProtocol"]]:
+        cls, llm_config: LLMConfig | dict[str, Any], logger: Logger, **kwargs: Any
+    ) -> Callable[[], "RealtimeClientProtocol"] | None:
         """Create a Realtime API client.
 
         Args:

autogen/agentchat/realtime/experimental/clients/oai/rtc_client.py

@@ -3,10 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import json
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from logging import Logger, getLogger
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from autogen.import_utils import optional_import_block, require_optional_import
 
@@ -37,9 +37,9 @@ class OpenAIRealtimeWebRTCClient(RealtimeClientBase):
     def __init__(
         self,
         *,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         websocket: "WebSocket",
-        logger: Optional[Logger] = None,
+        logger: Logger | None = None,
     ) -> None:
         """(Experimental) Client for OpenAI Realtime API.
 
@@ -218,8 +218,8 @@ class OpenAIRealtimeWebRTCClient(RealtimeClientBase):
 
     @classmethod
     def get_factory(
-        cls, llm_config: Union[LLMConfig, dict[str, Any]], logger: Logger, **kwargs: Any
-    ) -> Optional[Callable[[], "RealtimeClientProtocol"]]:
+        cls, llm_config: LLMConfig | dict[str, Any], logger: Logger, **kwargs: Any
+    ) -> Callable[[], "RealtimeClientProtocol"] | None:
         """Create a Realtime API client.
 
         Args:

autogen/agentchat/realtime/experimental/clients/realtime_client.py

@@ -3,9 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
+from contextlib import AbstractAsyncContextManager
 from logging import Logger
-from typing import Any, AsyncContextManager, Callable, Literal, Optional, Protocol, TypeVar, Union, runtime_checkable
+from typing import Any, Literal, Protocol, TypeVar, runtime_checkable
 
 from asyncer import create_task_group
 
@@ -66,7 +67,7 @@ class RealtimeClientProtocol(Protocol):
         """
         ...
 
-    def connect(self) -> AsyncContextManager[None]: ...
+    def connect(self) -> AbstractAsyncContextManager[None]: ...
 
     def read_events(self) -> AsyncGenerator[RealtimeEvent, None]:
         """Read events from a Realtime Client."""
@@ -89,8 +90,8 @@ class RealtimeClientProtocol(Protocol):
 
     @classmethod
     def get_factory(
-        cls, llm_config: Union[LLMConfig, dict[str, Any]], logger: Logger, **kwargs: Any
-    ) -> Optional[Callable[[], "RealtimeClientProtocol"]]:
+        cls, llm_config: LLMConfig | dict[str, Any], logger: Logger, **kwargs: Any
+    ) -> Callable[[], "RealtimeClientProtocol"] | None:
         """Create a Realtime API client.
 
         Args:
@@ -108,10 +109,10 @@ class RealtimeClientBase:
     def __init__(self):
         self._eventQueue = asyncio.Queue()
 
-    async def add_event(self, event: Optional[RealtimeEvent]):
+    async def add_event(self, event: RealtimeEvent | None):
         await self._eventQueue.put(event)
 
-    async def get_event(self) -> Optional[RealtimeEvent]:
+    async def get_event(self) -> RealtimeEvent | None:
         return await self._eventQueue.get()
 
     async def _read_from_connection_task(self):
@@ -134,7 +135,7 @@ class RealtimeClientBase:
                     break
 
     async def queue_input_audio_buffer_delta(self, audio: str) -> None:
-        """queue InputAudioBufferDelta.
+        """Queue InputAudioBufferDelta.
 
         Args:
             audio (str): The audio.
@@ -170,7 +171,7 @@ def register_realtime_client() -> Callable[[type[T]], type[T]]:
 
 
 @export_module("autogen.agentchat.realtime.experimental.clients")
-def get_client(llm_config: Union[LLMConfig, dict[str, Any]], logger: Logger, **kwargs: Any) -> "RealtimeClientProtocol":
+def get_client(llm_config: LLMConfig | dict[str, Any], logger: Logger, **kwargs: Any) -> "RealtimeClientProtocol":
     """Get a registered Realtime API client.
 
     Args:

autogen/agentchat/realtime/experimental/realtime_agent.py

@@ -2,9 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from logging import Logger, getLogger
-from typing import Any, Callable, Optional, TypeVar, Union
+from typing import Any, TypeVar
 
 from anyio import lowlevel
 from asyncer import create_task_group
@@ -35,11 +36,11 @@ class RealtimeAgent:
         self,
         *,
         name: str,
-        audio_adapter: Optional[RealtimeObserver] = None,
+        audio_adapter: RealtimeObserver | None = None,
         system_message: str = "You are a helpful AI Assistant.",
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        logger: Optional[Logger] = None,
-        observers: Optional[list[RealtimeObserver]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        logger: Logger | None = None,
+        observers: list[RealtimeObserver] | None = None,
         **client_kwargs: Any,
     ):
         """(Experimental) Agent for interacting with the Realtime Clients.
@@ -127,9 +128,9 @@ class RealtimeAgent:
     def register_realtime_function(
         self,
         *,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-    ) -> Callable[[Union[F, Tool]], Tool]:
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Callable[[F | Tool], Tool]:
         """Decorator for registering a function to be used by an agent.
 
         Args:
@@ -140,7 +141,7 @@ class RealtimeAgent:
             Callable[[Union[F, Tool]], Tool]: The decorator for registering a function.
         """
 
-        def _decorator(func_or_tool: Union[F, Tool]) -> Tool:
+        def _decorator(func_or_tool: F | Tool) -> Tool:
             """Decorator for registering a function to be used by an agent.
 
             Args:

autogen/agentchat/realtime/experimental/realtime_observer.py

@@ -4,7 +4,7 @@
 
 from abc import ABC, abstractmethod
 from logging import Logger, getLogger
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from anyio import Event
 
@@ -24,14 +24,14 @@ global_logger = getLogger(__name__)
 class RealtimeObserver(ABC):
     """Observer for the OpenAI Realtime API."""
 
-    def __init__(self, *, logger: Optional[Logger] = None) -> None:
+    def __init__(self, *, logger: Logger | None = None) -> None:
         """Observer for the OpenAI Realtime API.
 
         Args:
             logger (Logger): The logger for the observer.
         """
         self._ready_event = Event()
-        self._agent: Optional[RealtimeAgent] = None
+        self._agent: RealtimeAgent | None = None
         self._logger = logger
 
     @property

autogen/agentchat/realtime/experimental/realtime_swarm.py

@@ -5,7 +5,8 @@
 import logging
 import warnings
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
 import anyio
 from asyncer import asyncify, create_task_group, syncify
@@ -42,7 +43,7 @@ logger = logging.getLogger(__name__)
 F = TypeVar("F", bound=Callable[..., Any])
 
 
-def message_to_dict(message: Union[dict[str, Any], str]) -> dict[str, Any]:
+def message_to_dict(message: dict[str, Any] | str) -> dict[str, Any]:
     if isinstance(message, str):
         return {"content": message}
     elif isinstance(message, dict):
@@ -51,9 +52,8 @@ def message_to_dict(message: Union[dict[str, Any], str]) -> dict[str, Any]:
         return dict(message)
 
 
-def parse_oai_message(message: Union[dict[str, Any], str], role: str, adressee: Agent) -> dict[str, Any]:
-    """
-    Parse a message into an OpenAI-compatible message format.
+def parse_oai_message(message: dict[str, Any] | str, role: str, adressee: Agent) -> dict[str, Any]:
+    """Parse a message into an OpenAI-compatible message format.
 
     Args:
         message: The message to parse.
@@ -111,9 +111,9 @@ class SwarmableAgent(Agent):
         self,
         name: str,
         system_message: str = "You are a helpful AI Assistant.",
-        is_termination_msg: Optional[Callable[..., bool]] = None,
-        description: Optional[str] = None,
-        silent: Optional[bool] = None,
+        is_termination_msg: Callable[..., bool] | None = None,
+        description: str | None = None,
+        silent: bool | None = None,
     ):
         self._oai_messages: dict[Agent, Any] = defaultdict(list)
 
@@ -156,20 +156,20 @@ class SwarmableAgent(Agent):
 
     def send(
         self,
-        message: Union[dict[str, Any], str],
+        message: dict[str, Any] | str,
         recipient: Agent,
-        request_reply: Optional[bool] = None,
-        silent: Optional[bool] = False,
+        request_reply: bool | None = None,
+        silent: bool | None = False,
     ) -> None:
         self._oai_messages[recipient].append(parse_oai_message(message, "assistant", recipient))
         recipient.receive(message, self, request_reply)
 
     def receive(
         self,
-        message: Union[dict[str, Any], str],
+        message: dict[str, Any] | str,
         sender: Agent,
-        request_reply: Optional[bool] = None,
-        silent: Optional[bool] = False,
+        request_reply: bool | None = None,
+        silent: bool | None = False,
     ) -> None:
         self._oai_messages[sender].append(parse_oai_message(message, "user", self))
         if request_reply is False or (request_reply is None and self.reply_at_receive[sender] is False):
@@ -180,10 +180,10 @@ class SwarmableAgent(Agent):
 
     def generate_reply(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
+        messages: list[dict[str, Any]] | None = None,
         sender: Optional["Agent"] = None,
         **kwargs: Any,
-    ) -> Union[str, dict[str, Any], None]:
+    ) -> str | dict[str, Any] | None:
         if messages is None:
             if sender is None:
                 raise ValueError("Either messages or sender must be provided.")
@@ -195,20 +195,20 @@ class SwarmableAgent(Agent):
 
     def check_termination_and_human_reply(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
-        sender: Optional[Agent] = None,
-        config: Optional[Any] = None,
-    ) -> tuple[bool, Union[str, None]]:
+        messages: list[dict[str, Any]] | None = None,
+        sender: Agent | None = None,
+        config: Any | None = None,
+    ) -> tuple[bool, str | None]:
         raise NotImplementedError
 
     def initiate_chat(
         self,
         recipient: ConversableAgent,
-        message: Union[dict[str, Any], str],
+        message: dict[str, Any] | str,
         clear_history: bool = True,
-        silent: Optional[bool] = False,
-        cache: Optional[AbstractCache] = None,
-        summary_args: Optional[dict[str, Any]] = {},
+        silent: bool | None = False,
+        cache: AbstractCache | None = None,
+        summary_args: dict[str, Any] | None = {},
         **kwargs: dict[str, Any],
     ) -> ChatResult:
         _chat_info = locals().copy()
@@ -235,25 +235,25 @@ class SwarmableAgent(Agent):
 
     async def a_generate_reply(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
+        messages: list[dict[str, Any]] | None = None,
         sender: Optional["Agent"] = None,
         **kwargs: Any,
-    ) -> Union[str, dict[str, Any], None]:
+    ) -> str | dict[str, Any] | None:
         return self.generate_reply(messages=messages, sender=sender, **kwargs)
 
     async def a_receive(
         self,
-        message: Union[dict[str, Any], str],
+        message: dict[str, Any] | str,
         sender: "Agent",
-        request_reply: Optional[bool] = None,
+        request_reply: bool | None = None,
     ) -> None:
         self.receive(message, sender, request_reply)
 
     async def a_send(
         self,
-        message: Union[dict[str, Any], str],
+        message: dict[str, Any] | str,
         recipient: "Agent",
-        request_reply: Optional[bool] = None,
+        request_reply: bool | None = None,
     ) -> None:
         self.send(message, recipient, request_reply)
 
@@ -262,7 +262,7 @@ class SwarmableAgent(Agent):
         """A dictionary of conversations from agent to list of messages."""
         return self._oai_messages
 
-    def last_message(self, agent: Optional[Agent] = None) -> Optional[dict[str, Any]]:
+    def last_message(self, agent: Agent | None = None) -> dict[str, Any] | None:
         if agent is None:
             n_conversations = len(self._oai_messages)
             if n_conversations == 0:
@@ -293,7 +293,7 @@ class SwarmableAgent(Agent):
     def _raise_exception_on_async_reply_functions(self) -> None:
         pass
 
-    def set_ui_tools(self, tools: Optional[list] = None) -> None:
+    def set_ui_tools(self, tools: list | None = None) -> None:
         """Set UI tools for the agent."""
         pass
 
@@ -302,7 +302,7 @@ class SwarmableAgent(Agent):
         pass
 
     @staticmethod
-    def _last_msg_as_summary(sender: Agent, recipient: Agent, summary_args: Optional[dict[str, Any]]) -> str:
+    def _last_msg_as_summary(sender: Agent, recipient: Agent, summary_args: dict[str, Any] | None) -> str:
         """Get a chat summary from the last message of the recipient."""
         summary = ""
         try:
@@ -324,9 +324,9 @@ if TYPE_CHECKING:
     def _create_swarmable_agent(
         name: str,
         system_message: str,
-        is_termination_msg: Optional[Callable[..., bool]],
-        description: Optional[str],
-        silent: Optional[bool],
+        is_termination_msg: Callable[..., bool] | None,
+        description: str | None,
+        silent: bool | None,
     ) -> LLMAgent:
         return SwarmableAgent(
             name=name,
@@ -343,7 +343,7 @@ class SwarmableRealtimeAgent(SwarmableAgent):
         realtime_agent: "RealtimeAgent",
         initial_agent: ConversableAgent,
         agents: list[ConversableAgent],
-        question_message: Optional[str] = None,
+        question_message: str | None = None,
     ) -> None:
         self._initial_agent = initial_agent
         self._agents = agents
@@ -401,10 +401,10 @@ class SwarmableRealtimeAgent(SwarmableAgent):
 
     def check_termination_and_human_reply(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
-        sender: Optional[Agent] = None,
-        config: Optional[Any] = None,
-    ) -> tuple[bool, Optional[str]]:
+        messages: list[dict[str, Any]] | None = None,
+        sender: Agent | None = None,
+        config: Any | None = None,
+    ) -> tuple[bool, str | None]:
         """Check if the conversation should be terminated and if the agent should reply.
 
         Called when its agents turn in the chat conversation.
@@ -431,7 +431,7 @@ class SwarmableRealtimeAgent(SwarmableAgent):
     def start_chat(self) -> None:
         raise NotImplementedError
 
-    def configure_realtime_agent(self, system_message: Optional[str]) -> None:
+    def configure_realtime_agent(self, system_message: str | None) -> None:
         realtime_agent = self._realtime_agent
 
         logger = realtime_agent.logger
@@ -466,8 +466,8 @@ def register_swarm(
     realtime_agent: "RealtimeAgent",
     initial_agent: ConversableAgent,
     agents: list[ConversableAgent],
-    system_message: Optional[str] = None,
-    question_message: Optional[str] = None,
+    system_message: str | None = None,
+    question_message: str | None = None,
 ) -> None:
     """Create a SwarmableRealtimeAgent.
 

autogen/agentchat/user_proxy_agent.py

@@ -4,7 +4,8 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-from typing import Any, Callable, Literal, Optional, Union
+from collections.abc import Callable
+from typing import Any, Literal
 
 from ..doc_utils import export_module
 from ..llm_config import LLMConfig
@@ -35,15 +36,15 @@ class UserProxyAgent(ConversableAgent):
     def __init__(
         self,
         name: str,
-        is_termination_msg: Optional[Callable[[dict[str, Any]], bool]] = None,
-        max_consecutive_auto_reply: Optional[int] = None,
+        is_termination_msg: Callable[[dict[str, Any]], bool] | None = None,
+        max_consecutive_auto_reply: int | None = None,
         human_input_mode: Literal["ALWAYS", "TERMINATE", "NEVER"] = "ALWAYS",
-        function_map: Optional[dict[str, Callable[..., Any]]] = None,
-        code_execution_config: Union[dict[str, Any], Literal[False]] = {},
-        default_auto_reply: Optional[Union[str, dict[str, Any]]] = "",
-        llm_config: Optional[Union[LLMConfig, dict[str, Any], Literal[False]]] = False,
-        system_message: Optional[Union[str, list[str]]] = "",
-        description: Optional[str] = None,
+        function_map: dict[str, Callable[..., Any]] | None = None,
+        code_execution_config: dict[str, Any] | Literal[False] = {},
+        default_auto_reply: str | dict[str, Any] | None = "",
+        llm_config: LLMConfig | dict[str, Any] | Literal[False] | None = False,
+        system_message: str | list[str] | None = "",
+        description: str | None = None,
         **kwargs: Any,
     ):
         """Args:

autogen/agentchat/utils.py

@@ -5,14 +5,14 @@
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
 import re
-from typing import Any, Optional, Union
+from typing import Any
 
 from ..doc_utils import export_module
 from .agent import Agent
 
 
 def consolidate_chat_info(
-    chat_info: Union[dict[str, Any], list[dict[str, Any]]], uniform_sender: Optional[Agent] = None
+    chat_info: dict[str, Any] | list[dict[str, Any]], uniform_sender: Agent | None = None
 ) -> None:
     if isinstance(chat_info, dict):
         chat_info = [chat_info]
@@ -101,7 +101,7 @@ def gather_usage_summary(agents: list[Agent]) -> dict[str, dict[str, Any]]:
     }
 
 
-def parse_tags_from_content(tag: str, content: Union[str, list[dict[str, Any]]]) -> list[dict[str, Any]]:
+def parse_tags_from_content(tag: str, content: str | list[dict[str, Any]]) -> list[dict[str, Any]]:
     """Parses HTML style tags from message contents.
 
     The parsing is done by looking for patterns in the text that match the format of HTML tags. The tag to be parsed is

autogen/agents/contrib/time/time_reply_agent.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional
+from typing import Any
 
 from .... import Agent, ConversableAgent, OpenAIWrapper
 from ....doc_utils import export_module
@@ -16,7 +16,8 @@ class TimeReplyAgent(ConversableAgent):
 
     Use it is as a reference for creating new agents with a reply-based approach (as opposed to tool-based).
 
-    This agent will return the date and time whenever it needs to reply."""
+    This agent will return the date and time whenever it needs to reply.
+    """
 
     DEFAULT_SYSTEM_MESSAGE = "You are a calendar agent that just returns the date and time."
 
@@ -51,9 +52,9 @@ class TimeReplyAgent(ConversableAgent):
         # may even contain another AG2 workflow inside it
         def get_date_time_reply(
             agent: ConversableAgent,
-            messages: Optional[list[dict[str, Any]]] = None,
-            sender: Optional[Agent] = None,
-            config: Optional[OpenAIWrapper] = None,
+            messages: list[dict[str, Any]] | None = None,
+            sender: Agent | None = None,
+            config: OpenAIWrapper | None = None,
         ) -> tuple[bool, dict[str, Any]]:
             from datetime import datetime
 

autogen/agents/contrib/time/time_tool_agent.py

@@ -17,7 +17,8 @@ class TimeToolAgent(ConversableAgent):
 
     Use it is as a reference for creating new agents with a tool-based approach (as opposed to reply-based).
 
-    This agent will call the TimeTool and return the date and time whenever it needs to reply."""
+    This agent will call the TimeTool and return the date and time whenever it needs to reply.
+    """
 
     DEFAULT_SYSTEM_MESSAGE = (
         "You are a calendar agent that uses tools to return the date and time. "