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

autogen/agentchat/group/patterns/auto.py

@@ -2,7 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Optional
 
 from ..context_variables import ContextVariables
 from ..targets.group_manager_target import GroupManagerSelectionMessage, GroupManagerTarget
@@ -28,11 +29,11 @@ class AutoPattern(Pattern):
         initial_agent: "ConversableAgent",
         agents: list["ConversableAgent"],
         user_agent: Optional["ConversableAgent"] = None,
-        group_manager_args: Optional[dict[str, Any]] = None,
-        context_variables: Optional[ContextVariables] = None,
-        selection_message: Optional[GroupManagerSelectionMessage] = None,
+        group_manager_args: dict[str, Any] | None = None,
+        context_variables: ContextVariables | None = None,
+        selection_message: GroupManagerSelectionMessage | None = None,
         exclude_transit_message: bool = True,
-        summary_method: Optional[Union[str, Callable[..., Any]]] = "last_msg",
+        summary_method: str | Callable[..., Any] | None = "last_msg",
     ):
         """Initialize the AutoPattern.
 
@@ -70,8 +71,8 @@ class AutoPattern(Pattern):
     def prepare_group_chat(
         self,
         max_rounds: int,
-        messages: Union[list[dict[str, Any]], str],
-    ) -> Tuple[
+        messages: list[dict[str, Any]] | str,
+    ) -> tuple[
         list["ConversableAgent"],
         list["ConversableAgent"],
         Optional["ConversableAgent"],

autogen/agentchat/group/patterns/manual.py

@@ -2,7 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Optional
 
 from ..context_variables import ContextVariables
 from ..group_tool_executor import GroupToolExecutor
@@ -22,10 +23,10 @@ class ManualPattern(Pattern):
         initial_agent: "ConversableAgent",
         agents: list["ConversableAgent"],
         user_agent: Optional["ConversableAgent"] = None,
-        group_manager_args: Optional[dict[str, Any]] = None,
-        context_variables: Optional[ContextVariables] = None,
+        group_manager_args: dict[str, Any] | None = None,
+        context_variables: ContextVariables | None = None,
         exclude_transit_message: bool = True,
-        summary_method: Optional[Union[str, Callable[..., Any]]] = "last_msg",
+        summary_method: str | Callable[..., Any] | None = "last_msg",
     ):
         """Initialize the ManualPattern.
 
@@ -57,8 +58,8 @@ class ManualPattern(Pattern):
     def prepare_group_chat(
         self,
         max_rounds: int,
-        messages: Union[list[dict[str, Any]], str],
-    ) -> Tuple[
+        messages: list[dict[str, Any]] | str,
+    ) -> tuple[
         list["ConversableAgent"],
         list["ConversableAgent"],
         Optional["ConversableAgent"],

autogen/agentchat/group/patterns/pattern.py

@@ -6,7 +6,8 @@
 # Uses the group chat or the agents' handoffs to create a pattern
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Optional
 
 from ..context_variables import ContextVariables
 from ..group_utils import (
@@ -43,11 +44,11 @@ class Pattern(ABC):
         initial_agent: "ConversableAgent",
         agents: list["ConversableAgent"],
         user_agent: Optional["ConversableAgent"] = None,
-        group_manager_args: Optional[dict[str, Any]] = None,
-        context_variables: Optional[ContextVariables] = None,
-        group_after_work: Optional[TransitionTarget] = None,
+        group_manager_args: dict[str, Any] | None = None,
+        context_variables: ContextVariables | None = None,
+        group_after_work: TransitionTarget | None = None,
         exclude_transit_message: bool = True,
-        summary_method: Optional[Union[str, Callable[..., Any]]] = "last_msg",
+        summary_method: str | Callable[..., Any] | None = "last_msg",
     ):
         """Initialize the pattern with the required components.
 
@@ -74,8 +75,8 @@ class Pattern(ABC):
     def prepare_group_chat(
         self,
         max_rounds: int,
-        messages: Union[list[dict[str, Any]], str],
-    ) -> Tuple[
+        messages: list[dict[str, Any]] | str,
+    ) -> tuple[
         list["ConversableAgent"],
         list["ConversableAgent"],
         Optional["ConversableAgent"],
@@ -185,10 +186,10 @@ class Pattern(ABC):
         initial_agent: "ConversableAgent",
         agents: list["ConversableAgent"],
         user_agent: Optional["ConversableAgent"] = None,
-        group_manager_args: Optional[dict[str, Any]] = None,
-        context_variables: Optional[ContextVariables] = None,
+        group_manager_args: dict[str, Any] | None = None,
+        context_variables: ContextVariables | None = None,
         exclude_transit_message: bool = True,
-        summary_method: Optional[Union[str, Callable[..., Any]]] = "last_msg",
+        summary_method: str | Callable[..., Any] | None = "last_msg",
     ) -> "DefaultPattern":
         """Create a default pattern with minimal configuration.
 
@@ -228,8 +229,8 @@ class DefaultPattern(Pattern):
     def prepare_group_chat(
         self,
         max_rounds: int,
-        messages: Union[list[dict[str, Any]], str],
-    ) -> Tuple[
+        messages: list[dict[str, Any]] | str,
+    ) -> tuple[
         list["ConversableAgent"],
         list["ConversableAgent"],
         Optional["ConversableAgent"],

autogen/agentchat/group/patterns/random.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional
 
 from ..context_variables import ContextVariables
 from ..targets.transition_target import RandomAgentTarget, TransitionTarget
@@ -36,8 +36,8 @@ class RandomPattern(Pattern):
     def prepare_group_chat(
         self,
         max_rounds: int,
-        messages: Union[list[dict[str, Any]], str],
-    ) -> Tuple[
+        messages: list[dict[str, Any]] | str,
+    ) -> tuple[
         list["ConversableAgent"],
         list["ConversableAgent"],
         Optional["ConversableAgent"],

autogen/agentchat/group/patterns/round_robin.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional
 
 from ..context_variables import ContextVariables
 from ..targets.transition_target import AgentTarget, TransitionTarget
@@ -47,8 +47,8 @@ class RoundRobinPattern(Pattern):
     def prepare_group_chat(
         self,
         max_rounds: int,
-        messages: Union[list[dict[str, Any]], str],
-    ) -> Tuple[
+        messages: list[dict[str, Any]] | str,
+    ) -> tuple[
         list["ConversableAgent"],
         list["ConversableAgent"],
         Optional["ConversableAgent"],

autogen/agentchat/group/reply_result.py

@@ -6,8 +6,6 @@
 __all__ = ["ReplyResult"]
 
 
-from typing import Optional
-
 from pydantic import BaseModel
 
 from .context_variables import ContextVariables
@@ -18,8 +16,8 @@ class ReplyResult(BaseModel):
     """Result of a tool call that is used to provide the return message and the target to transition to."""
 
     message: str
-    target: Optional[TransitionTarget] = None
-    context_variables: Optional[ContextVariables] = None
+    target: TransitionTarget | None = None
+    context_variables: ContextVariables | None = None
 
     def __str__(self) -> str:
         """The string representation for ReplyResult will be just the message."""

autogen/agentchat/group/speaker_selection_result.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
@@ -19,11 +19,11 @@ class SpeakerSelectionResult(BaseModel):
     This class can return an Agent, a None to end the conversation, or a string for a speaker selection method.
     """
 
-    terminate: Optional[bool] = None
-    agent_name: Optional[str] = None
-    speaker_selection_method: Optional[str] = None
+    terminate: bool | None = None
+    agent_name: str | None = None
+    speaker_selection_method: str | None = None
 
-    def get_speaker_selection_result(self, groupchat: "GroupChat") -> Optional[Union[Agent, str]]:
+    def get_speaker_selection_result(self, groupchat: "GroupChat") -> Agent | str | None:
         """Get the speaker selection result. If None, the conversation will end."""
         if self.agent_name is not None:
             # Find the agent by name in the groupchat

autogen/agentchat/group/targets/group_chat_target.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional
 
 from pydantic import BaseModel
 
@@ -25,10 +25,11 @@ __all__ = ["GroupChatConfig", "GroupChatTarget"]
 class GroupChatConfig(BaseModel):
     """Configuration for a group chat transition target.
 
-    Note: If context_variables are not passed in, the outer context variables will be passed in"""
+    Note: If context_variables are not passed in, the outer context variables will be passed in
+    """
 
     pattern: "Pattern"
-    messages: Union[list[dict[str, Any]], str]
+    messages: list[dict[str, Any]] | str
     max_rounds: int = 20
 
 
@@ -88,10 +89,10 @@ class GroupChatTarget(TransitionTarget):
         # Define the reply function that will run the group chat
         def group_chat_reply(
             agent: "ConversableAgent",
-            messages: Optional[list[dict[str, Any]]] = None,
+            messages: list[dict[str, Any]] | None = None,
             sender: Optional["Agent"] = None,
-            config: Optional[Any] = None,
-        ) -> tuple[bool, Optional[dict[str, Any]]]:
+            config: Any | None = None,
+        ) -> tuple[bool, dict[str, Any] | None]:
             """Run the inner group chat and return its results as a reply."""
             # Get the configuration stored directly on the agent
             group_config = agent._group_chat_config  # type: ignore[attr-defined]

autogen/agentchat/group/targets/group_manager_target.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Optional
 
 from pydantic import BaseModel, field_validator
 
@@ -24,7 +24,7 @@ __all__ = ["GroupManagerTarget"]
 def prepare_groupchat_auto_speaker(
     groupchat: "GroupChat",
     last_group_agent: "ConversableAgent",
-    group_chat_manager_selection_msg: Optional[Any],
+    group_chat_manager_selection_msg: Any | None,
 ) -> None:
     """Prepare the group chat for auto speaker selection, includes updating or restore the groupchat speaker selection message.
 
@@ -88,7 +88,7 @@ class GroupManagerSelectionMessageContextStr(GroupManagerSelectionMessage):
     # We will replace {agentlist} with another term and return it later for use with the internal group chat auto speaker selection
     # Otherwise our format will fail
     @field_validator("context_str_template", mode="before")
-    def _replace_agentlist_placeholder(cls: Type["GroupManagerSelectionMessageContextStr"], v: Any) -> Union[str, Any]:  # noqa: N805
+    def _replace_agentlist_placeholder(cls: type["GroupManagerSelectionMessageContextStr"], v: Any) -> str | Any:  # noqa: N805
         """Replace {agentlist} placeholder before validation/assignment."""
         if isinstance(v, str):
             if "{agentlist}" in v:
@@ -112,7 +112,7 @@ class GroupManagerSelectionMessageContextStr(GroupManagerSelectionMessage):
 class GroupManagerTarget(TransitionTarget):
     """Target that represents an agent by name."""
 
-    selection_message: Optional[GroupManagerSelectionMessage] = None
+    selection_message: GroupManagerSelectionMessage | None = None
 
     def can_resolve_for_speaker_selection(self) -> bool:
         """Check if the target can resolve for speaker selection."""

autogen/agentchat/group/targets/transition_target.py

@@ -71,7 +71,8 @@ class TransitionTarget(BaseModel):
     def activate_target(self, groupchat: "GroupChat") -> None:
         """Activate the target in the groupchat, setting the next target for GroupToolExecutor.
 
-        The Tool Executor's next target attribute will be picked up on the next iteration when _determine_next_agent is called"""
+        The Tool Executor's next target attribute will be picked up on the next iteration when _determine_next_agent is called
+        """
         for agent in groupchat.agents:  # type: ignore[attr-defined]
             # get the GroupToolExecutor agent
             if type(agent).__name__ == "GroupToolExecutor":

autogen/agentchat/groupchat.py

@@ -10,8 +10,9 @@ import logging
 import random
 import re
 import sys
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Callable, Literal, Optional, Union
+from typing import Any, Literal
 
 from ..code_utils import content_str
 from ..doc_utils import export_module
@@ -30,8 +31,7 @@ from ..events.agent_events import (
 from ..exception_utils import AgentNameConflictError, NoEligibleSpeakerError, UndefinedNextAgentError
 from ..graph_utils import check_graph_validity, invert_disallowed_to_allowed
 from ..io.base import IOStream
-from ..llm_config import LLMConfig
-from ..oai.client import ModelClient
+from ..llm_config import LLMConfig, ModelClient
 from ..runtime_logging import log_new_agent, logging_enabled
 from .agent import Agent
 from .contrib.capabilities import transform_messages
@@ -134,10 +134,10 @@ class GroupChat:
     max_round: int = 10
     admin_name: str = "Admin"
     func_call_filter: bool = True
-    speaker_selection_method: Union[Literal["auto", "manual", "random", "round_robin"], Callable[..., Any]] = "auto"
+    speaker_selection_method: Literal["auto", "manual", "random", "round_robin"] | Callable[..., Any] = "auto"
     max_retries_for_selecting_speaker: int = 2
-    allow_repeat_speaker: Optional[Union[bool, list[Agent]]] = None
-    allowed_or_disallowed_speaker_transitions: Optional[dict[str, Any]] = None
+    allow_repeat_speaker: bool | list[Agent] | None = None
+    allowed_or_disallowed_speaker_transitions: dict[str, Any] | None = None
     speaker_transitions_type: Literal["allowed", "disallowed", None] = None
     enable_clear_history: bool = False
     send_introductions: bool = False
@@ -159,11 +159,11 @@ class GroupChat:
     The names are case-sensitive and should not be abbreviated or changed.
     The only names that are accepted are {agentlist}.
     Respond with ONLY the name of the speaker and DO NOT provide a reason."""
-    select_speaker_transform_messages: Optional[transform_messages.TransformMessages] = None
-    select_speaker_auto_verbose: Optional[bool] = False
-    select_speaker_auto_model_client_cls: Optional[Union[ModelClient, list[ModelClient]]] = None
-    select_speaker_auto_llm_config: Optional[Union[LLMConfig, dict[str, Any], Literal[False]]] = None
-    role_for_select_speaker_messages: Optional[str] = "system"
+    select_speaker_transform_messages: transform_messages.TransformMessages | None = None
+    select_speaker_auto_verbose: bool | None = False
+    select_speaker_auto_model_client_cls: ModelClient | list[ModelClient] | None = None
+    select_speaker_auto_llm_config: LLMConfig | dict[str, Any] | Literal[False] | None = None
+    role_for_select_speaker_messages: str | None = "system"
 
     _VALID_SPEAKER_SELECTION_METHODS = ["auto", "manual", "random", "round_robin"]
     _VALID_SPEAKER_TRANSITIONS_TYPE = ["allowed", "disallowed", None]
@@ -315,9 +315,7 @@ class GroupChat:
         message["content"] = content_str(message["content"])
         self.messages.append(message)
 
-    def agent_by_name(
-        self, name: str, recursive: bool = False, raise_on_name_conflict: bool = False
-    ) -> Optional[Agent]:
+    def agent_by_name(self, name: str, recursive: bool = False, raise_on_name_conflict: bool = False) -> Agent | None:
         """Returns the agent with a given name. If recursive is True, it will search in nested teams."""
         agents = self.nested_agents() if recursive else self.agents
         filtered_agents = [agent for agent in agents if agent.name == name]
@@ -336,7 +334,7 @@ class GroupChat:
                 agents.extend(agent.groupchat.nested_agents())
         return agents
 
-    def next_agent(self, agent: Agent, agents: Optional[list[Agent]] = None) -> Agent:
+    def next_agent(self, agent: Agent, agents: list[Agent] | None = None) -> Agent:
         """Return the next agent in the list."""
         if agents is None:
             agents = self.agents
@@ -360,7 +358,7 @@ class GroupChat:
         # Explicitly handle cases where no valid next agent exists in the provided subset.
         raise UndefinedNextAgentError()
 
-    def select_speaker_msg(self, agents: Optional[list[Agent]] = None) -> str:
+    def select_speaker_msg(self, agents: list[Agent] | None = None) -> str:
         """Return the system message for selecting the next speaker. This is always the *first* message in the context."""
         if agents is None:
             agents = self.agents
@@ -371,7 +369,7 @@ class GroupChat:
         return_msg = self.select_speaker_message_template.format(roles=roles, agentlist=agentlist)
         return return_msg
 
-    def select_speaker_prompt(self, agents: Optional[list[Agent]] = None) -> str:
+    def select_speaker_prompt(self, agents: list[Agent] | None = None) -> str:
         """Return the floating system prompt selecting the next speaker.
         This is always the *last* message in the context.
         Will return None if the select_speaker_prompt_template is None.
@@ -387,7 +385,7 @@ class GroupChat:
         return_prompt = f"{self.select_speaker_prompt_template}".replace("{agentlist}", agentlist)
         return return_prompt
 
-    def introductions_msg(self, agents: Optional[list[Agent]] = None) -> str:
+    def introductions_msg(self, agents: list[Agent] | None = None) -> str:
         """Return the system message for selecting the next speaker. This is always the *first* message in the context."""
         if agents is None:
             agents = self.agents
@@ -398,7 +396,7 @@ class GroupChat:
 
         return f"{intro_msg}\n\n{participant_roles}"
 
-    def manual_select_speaker(self, agents: Optional[list[Agent]] = None) -> Union[Agent, None]:
+    def manual_select_speaker(self, agents: list[Agent] | None = None) -> Agent | None:
         """Manually select the next speaker."""
         iostream = IOStream.get_default()
 
@@ -429,7 +427,7 @@ class GroupChat:
                 iostream.send(SelectSpeakerInvalidInputEvent(agents=agents))
         return None
 
-    def random_select_speaker(self, agents: Optional[list[Agent]] = None) -> Union[Agent, None]:
+    def random_select_speaker(self, agents: list[Agent] | None = None) -> Agent | None:
         """Randomly select the next speaker."""
         if agents is None:
             agents = self.agents
@@ -438,7 +436,7 @@ class GroupChat:
     def _prepare_and_select_agents(
         self,
         last_speaker: Agent,
-    ) -> tuple[Optional[Agent], list[Agent], Optional[list[dict[str, Any]]]]:
+    ) -> tuple[Agent | None, list[Agent], list[dict[str, Any]] | None]:
         # If self.speaker_selection_method is a callable, call it to get the next speaker.
         # If self.speaker_selection_method is a string, return it.
         speaker_selection_method = self.speaker_selection_method
@@ -591,7 +589,7 @@ class GroupChat:
         # auto speaker selection with 2-agent chat
         return await self.a_auto_select_speaker(last_speaker, selector, messages, agents)
 
-    def _finalize_speaker(self, last_speaker: Agent, final: bool, name: str, agents: Optional[list[Agent]]) -> Agent:
+    def _finalize_speaker(self, last_speaker: Agent, final: bool, name: str, agents: list[Agent] | None) -> Agent:
         if not final:
             # the LLM client is None, thus no reply is generated. Use round robin instead.
             return self.next_agent(last_speaker, agents)
@@ -653,7 +651,7 @@ class GroupChat:
             self._register_client_from_config(agent, self.select_speaker_auto_llm_config)
 
     def _create_internal_agents(
-        self, agents, max_attempts, messages, validate_speaker_name, selector: Optional[ConversableAgent] = None
+        self, agents, max_attempts, messages, validate_speaker_name, selector: ConversableAgent | None = None
     ):
         checking_agent = ConversableAgent("checking_agent", default_auto_reply=max_attempts)
 
@@ -691,8 +689,8 @@ class GroupChat:
         self,
         last_speaker: Agent,
         selector: ConversableAgent,
-        messages: Optional[list[dict[str, Any]]],
-        agents: Optional[list[Agent]],
+        messages: list[dict[str, Any]] | None,
+        agents: list[Agent] | None,
     ) -> Agent:
         """Selects next speaker for the "auto" speaker selection method. Utilises its own two-agent chat to determine the next speaker and supports requerying.
 
@@ -726,9 +724,7 @@ class GroupChat:
         attempt = 0
 
         # Registered reply function for checking_agent, checks the result of the response for agent names
-        def validate_speaker_name(
-            recipient, messages, sender, config
-        ) -> tuple[bool, Optional[Union[str, dict[str, Any]]]]:
+        def validate_speaker_name(recipient, messages, sender, config) -> tuple[bool, str | dict[str, Any] | None]:
             # The number of retries left, starting at max_retries_for_selecting_speaker
             nonlocal attempts_left
             nonlocal attempt
@@ -776,8 +772,8 @@ class GroupChat:
         self,
         last_speaker: Agent,
         selector: ConversableAgent,
-        messages: Optional[list[dict[str, Any]]],
-        agents: Optional[list[Agent]],
+        messages: list[dict[str, Any]] | None,
+        agents: list[Agent] | None,
     ) -> Agent:
         """(Asynchronous) Selects next speaker for the "auto" speaker selection method. Utilises its own two-agent chat to determine the next speaker and supports requerying.
 
@@ -810,9 +806,7 @@ class GroupChat:
         attempt = 0
 
         # Registered reply function for checking_agent, checks the result of the response for agent names
-        def validate_speaker_name(
-            recipient, messages, sender, config
-        ) -> tuple[bool, Optional[Union[str, dict[str, Any]]]]:
+        def validate_speaker_name(recipient, messages, sender, config) -> tuple[bool, str | dict[str, Any] | None]:
             # The number of retries left, starting at max_retries_for_selecting_speaker
             nonlocal attempts_left
             nonlocal attempt
@@ -857,21 +851,22 @@ class GroupChat:
 
     def _validate_speaker_name(
         self, recipient, messages, sender, config, attempts_left, attempt, agents
-    ) -> tuple[bool, Optional[Union[str, dict[str, Any]]]]:
+    ) -> tuple[bool, str | dict[str, Any] | None]:
         """Validates the speaker response for each round in the internal 2-agent
         chat within the  auto select speaker method.
 
         Used by auto_select_speaker and a_auto_select_speaker.
         """
         # Validate the speaker name selected
-        select_name = messages[-1]["content"].strip()
-
-        mentions = self._mentioned_agents(select_name, agents)
+        if messages and (name := messages[-1].get("content")):
+            mentions = self._mentioned_agents(name.strip(), agents)
+        else:
+            mentions = []
+        no_of_mentions = len(mentions)
 
         # Output the query and requery results
         if self.select_speaker_auto_verbose:
             iostream = IOStream.get_default()
-            no_of_mentions = len(mentions)
             if no_of_mentions == 1:
                 # Success on retry, we have just one name mentioned
                 iostream.send(
@@ -901,14 +896,14 @@ class GroupChat:
                     )
                 )
 
-        if len(mentions) == 1:
+        if no_of_mentions == 1:
             # Success on retry, we have just one name mentioned
             selected_agent_name = next(iter(mentions))
 
             # Add the selected agent to the response so we can return it
             messages.append({"role": "user", "content": f"[AGENT SELECTED]{selected_agent_name}"})
 
-        elif len(mentions) > 1:
+        elif no_of_mentions > 1:
             # More than one name on requery so add additional reminder prompt for next retry
 
             if attempts_left:
@@ -948,7 +943,7 @@ class GroupChat:
 
         return True, None
 
-    def _process_speaker_selection_result(self, result, last_speaker: ConversableAgent, agents: Optional[list[Agent]]):
+    def _process_speaker_selection_result(self, result, last_speaker: ConversableAgent, agents: list[Agent] | None):
         """Checks the result of the auto_select_speaker function, returning the
         agent to speak.
 
@@ -983,7 +978,7 @@ class GroupChat:
             roles.append(f"{agent.name}: {agent.description}".strip())
         return "\n".join(roles)
 
-    def _mentioned_agents(self, message_content: Union[str, list], agents: Optional[list[Agent]]) -> dict:
+    def _mentioned_agents(self, message_content: str | list, agents: list[Agent] | None) -> dict:
         """Counts the number of times each agent is mentioned in the provided message content.
         Agent names will match under any of the following conditions (all case-sensitive):
         - Exact name match
@@ -1026,9 +1021,10 @@ class GroupChat:
     def _run_input_guardrails(
         self,
         agent: "ConversableAgent",
-        messages: Optional[list[dict[str, Any]]] = None,
-    ) -> Optional[str]:
+        messages: list[dict[str, Any]] | None = None,
+    ) -> str | None:
         """Run input guardrails for an agent before the reply is generated.
+
         Args:
             agent (ConversableAgent): The agent whose input guardrails to run.
             messages (Optional[list[dict[str, Any]]]): The messages to check against the guardrails.
@@ -1043,6 +1039,7 @@ class GroupChat:
 
     def _run_output_guardrails(self, agent: "ConversableAgent", reply: str) -> None:
         """Run output guardrails for an agent after the reply is generated.
+
         Args:
             agent (ConversableAgent): The agent whose output guardrails to run.
             reply (str): The reply generated by the agent.
@@ -1063,11 +1060,11 @@ class GroupChatManager(ConversableAgent):
     def __init__(
         self,
         groupchat: GroupChat,
-        name: Optional[str] = "chat_manager",
+        name: str | None = "chat_manager",
         # unlimited consecutive auto reply by default
-        max_consecutive_auto_reply: Optional[int] = sys.maxsize,
+        max_consecutive_auto_reply: int | None = sys.maxsize,
         human_input_mode: Literal["ALWAYS", "NEVER", "TERMINATE"] = "NEVER",
-        system_message: Optional[Union[str, list]] = "Group chat manager.",
+        system_message: str | list | None = "Group chat manager.",
         silent: bool = False,
         **kwargs: Any,
     ):
@@ -1177,10 +1174,10 @@ class GroupChatManager(ConversableAgent):
 
     def run_chat(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
-        sender: Optional[Agent] = None,
-        config: Optional[GroupChat] = None,
-    ) -> tuple[bool, Optional[str]]:
+        messages: list[dict[str, Any]] | None = None,
+        sender: Agent | None = None,
+        config: GroupChat | None = None,
+    ) -> tuple[bool, str | None]:
         """Run a group chat."""
         iostream = IOStream.get_default()
 
@@ -1293,9 +1290,9 @@ class GroupChatManager(ConversableAgent):
 
     async def a_run_chat(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
-        sender: Optional[Agent] = None,
-        config: Optional[GroupChat] = None,
+        messages: list[dict[str, Any]] | None = None,
+        sender: Agent | None = None,
+        config: GroupChat | None = None,
     ):
         """Run a group chat asynchronously."""
         iostream = IOStream.get_default()
@@ -1410,9 +1407,9 @@ class GroupChatManager(ConversableAgent):
 
     def resume(
         self,
-        messages: Union[list[dict[str, Any]], str],
-        remove_termination_string: Optional[Union[str, Callable[[str], str]]] = None,
-        silent: Optional[bool] = False,
+        messages: list[dict[str, Any]] | str,
+        remove_termination_string: str | Callable[[str], str] | None = None,
+        silent: bool | None = False,
     ) -> tuple[ConversableAgent, dict[str, Any]]:
         """Resumes a group chat using the previous messages as a starting point. Requires the agents, group chat, and group chat manager to be established
         as per the original group chat.
@@ -1513,9 +1510,9 @@ class GroupChatManager(ConversableAgent):
 
     async def a_resume(
         self,
-        messages: Union[list[dict[str, Any]], str],
-        remove_termination_string: Optional[Union[str, Callable[[str], str]]] = None,
-        silent: Optional[bool] = False,
+        messages: list[dict[str, Any]] | str,
+        remove_termination_string: str | Callable[[str], str] | None = None,
+        silent: bool | None = False,
     ) -> tuple[ConversableAgent, dict[str, Any]]:
         """Resumes a group chat using the previous messages as a starting point, asynchronously. Requires the agents, group chat, and group chat manager to be established
         as per the original group chat.
@@ -1639,7 +1636,7 @@ class GroupChatManager(ConversableAgent):
                 raise Exception(f"Agent name in message doesn't exist as agent in group chat: {message['name']}")
 
     def _process_resume_termination(
-        self, remove_termination_string: Union[str, Callable[[str], str]], messages: list[dict[str, Any]]
+        self, remove_termination_string: str | Callable[[str], str], messages: list[dict[str, Any]]
     ):
         """Removes termination string, if required, and checks if termination may occur.