ag2 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

autogen/agentchat/group/group_utils.py

@@ -82,6 +82,46 @@ def link_agents_to_group_manager(agents: list[Agent], group_chat_manager: Agent)
         agent._group_manager = group_chat_manager  # type: ignore[attr-defined]
 
 
+def _evaluate_after_works_conditions(
+    agent: "ConversableAgent",
+    groupchat: GroupChat,
+    user_agent: Optional["ConversableAgent"],
+) -> Optional[Union[Agent, str]]:
+    """Evaluate after_works context conditions for an agent.
+
+    Args:
+        agent: The agent to evaluate after_works conditions for
+        groupchat: The current group chat
+        user_agent: Optional user proxy agent
+
+    Returns:
+        The resolved speaker selection result if a condition matches, None otherwise
+    """
+    if not hasattr(agent, "handoffs") or not agent.handoffs.after_works:  # type: ignore[attr-defined]
+        return None
+
+    for after_work_condition in agent.handoffs.after_works:  # type: ignore[attr-defined]
+        # Check if condition is available
+        is_available = (
+            after_work_condition.available.is_available(agent, groupchat.messages)
+            if after_work_condition.available
+            else True
+        )
+
+        # Evaluate the condition (None condition means always true)
+        if is_available and (
+            after_work_condition.condition is None or after_work_condition.condition.evaluate(agent.context_variables)
+        ):
+            # Condition matched, resolve and return
+            return after_work_condition.target.resolve(
+                groupchat,
+                agent,
+                user_agent,
+            ).get_speaker_selection_result(groupchat)
+
+    return None
+
+
 def _run_oncontextconditions(
     agent: "ConversableAgent",
     messages: Optional[list[dict[str, Any]]] = None,
@@ -94,14 +134,10 @@ def _run_oncontextconditions(
             on_condition.available.is_available(agent, messages if messages else []) if on_condition.available else True
         )
 
-        if is_available and on_condition.condition.evaluate(agent.context_variables):
-            # Condition has been met, we'll set the Tool Executor's next target
-            # attribute and that will be picked up on the next iteration when
-            # _determine_next_agent is called
-            for agent in agent._group_manager.groupchat.agents:  # type: ignore[attr-defined]
-                if isinstance(agent, GroupToolExecutor):
-                    agent.set_next_target(on_condition.target)
-                    break
+        if is_available and (
+            on_condition.condition is None or on_condition.condition.evaluate(agent.context_variables)
+        ):
+            on_condition.target.activate_target(agent._group_manager.groupchat)  # type: ignore[attr-defined]
 
             transfer_name = on_condition.target.display_name()
 
@@ -161,12 +197,25 @@ def ensure_handoff_agents_in_group(agents: list["ConversableAgent"]) -> None:
                 and context_conditions.target.agent_name not in agent_names
             ):
                 raise ValueError("Agent in OnContextCondition Hand-offs must be in the agents list")
-        if (
-            agent.handoffs.after_work is not None
-            and isinstance(agent.handoffs.after_work, (AgentTarget, AgentNameTarget))
-            and agent.handoffs.after_work.agent_name not in agent_names
-        ):
-            raise ValueError("Agent in after work target Hand-offs must be in the agents list")
+        # Check after_works targets
+        for after_work_condition in agent.handoffs.after_works:
+            if (
+                isinstance(after_work_condition.target, (AgentTarget, AgentNameTarget))
+                and after_work_condition.target.agent_name not in agent_names
+            ):
+                raise ValueError("Agent in after work target Hand-offs must be in the agents list")
+
+
+def ensure_guardrail_agents_in_group(agents: list["ConversableAgent"]) -> None:
+    """Ensure the agents in handoffs are in the group chat."""
+    agent_names = [agent.name for agent in agents]
+    for agent in agents:
+        for guardrail in agent.input_guardrails + agent.output_guardrails:
+            if (
+                isinstance(guardrail.target, (AgentTarget, AgentNameTarget))
+                and guardrail.target.agent_name not in agent_names
+            ):
+                raise ValueError("Agent in guardrail's target must be in the agents list")
 
 
 def prepare_exclude_transit_messages(agents: list["ConversableAgent"]) -> None:
@@ -211,6 +260,9 @@ def prepare_group_agents(
     # Ensure all agents in hand-off after-works are in the passed in agents list
     ensure_handoff_agents_in_group(agents)
 
+    # Ensure all agents in guardrails are in the passed in agents list
+    ensure_guardrail_agents_in_group(agents)
+
     # Create Tool Executor for the group
     tool_execution = GroupToolExecutor()
 
@@ -320,17 +372,19 @@ def setup_context_variables(
     tool_execution: "ConversableAgent",
     agents: list["ConversableAgent"],
     manager: GroupChatManager,
+    user_agent: Optional["ConversableAgent"],
     context_variables: ContextVariables,
 ) -> None:
-    """Assign a common context_variables reference to all agents in the group, including the tool executor and group chat manager.
+    """Assign a common context_variables reference to all agents in the group, including the tool executor, group chat manager, and user proxy agent.
 
     Args:
         tool_execution: The tool execution agent.
         agents: List of all agents in the conversation.
         manager: GroupChatManager instance.
+        user_agent: Optional user proxy agent.
         context_variables: Context variables to assign to all agents.
     """
-    for agent in agents + [tool_execution] + [manager]:
+    for agent in agents + [tool_execution] + [manager] + ([user_agent] if user_agent else []):
         agent.context_variables = context_variables
 
 
@@ -426,22 +480,25 @@ def determine_next_agent(
 
     # If the user last spoke, return to the agent prior to them (if they don't have an after work, otherwise it's treated like any other agent)
     if user_agent and last_speaker == user_agent:
-        if user_agent.handoffs.after_work is None:
+        if not user_agent.handoffs.after_works:
             return last_agent_speaker
         else:
             last_agent_speaker = user_agent
 
     # AFTER WORK:
 
-    # Get the appropriate After Work condition (from the agent if they have one, otherwise the group level one)
-    after_work_condition = (
-        last_agent_speaker.handoffs.after_work  # type: ignore[attr-defined]
-        if last_agent_speaker.handoffs.after_work is not None  # type: ignore[attr-defined]
-        else group_after_work
+    # First, try to evaluate after_works context conditions
+    after_works_result = _evaluate_after_works_conditions(
+        last_agent_speaker,  # type: ignore[arg-type]
+        groupchat,
+        user_agent,
     )
+    if after_works_result is not None:
+        return after_works_result
 
+    # If no after_works conditions matched, use the group-level after_work
     # Resolve the next agent, termination, or speaker selection method
-    resolved_speaker_selection_result = after_work_condition.resolve(
+    resolved_speaker_selection_result = group_after_work.resolve(
         groupchat,
         last_agent_speaker,  # type: ignore[arg-type]
         user_agent,
@@ -525,10 +582,7 @@ def create_group_manager(
                 if (
                     len(agent.handoffs.get_context_conditions_by_target_type(GroupManagerTarget)) > 0
                     or len(agent.handoffs.get_llm_conditions_by_target_type(GroupManagerTarget)) > 0
-                    or (
-                        agent.handoffs.after_work is not None
-                        and isinstance(agent.handoffs.after_work, GroupManagerTarget)
-                    )
+                    or any(isinstance(aw.target, GroupManagerTarget) for aw in agent.handoffs.after_works)
                 ):
                     has_group_manager_target = True
                     break

autogen/agentchat/group/guardrails.py

@@ -0,0 +1,171 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+import re
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from ...oai.client import OpenAIWrapper
+
+if TYPE_CHECKING:
+    from ...llm_config import LLMConfig
+    from .targets.transition_target import TransitionTarget
+
+
+class GuardrailResult(BaseModel):
+    """Represents the outcome of a guardrail check."""
+
+    activated: bool
+    justification: str = Field(default="No justification provided")
+
+    def __str__(self) -> str:
+        return f"Guardrail Result: {self.activated}\nJustification: {self.justification}"
+
+    @staticmethod
+    def parse(text: str) -> "GuardrailResult":
+        """Parses a JSON string into a GuardrailResult object.
+
+        Args:
+            text (str): The JSON string to parse.
+
+        Returns:
+            GuardrailResult: The parsed GuardrailResult object.
+        """
+        try:
+            data = json.loads(text)
+            return GuardrailResult(**data)
+        except (json.JSONDecodeError, ValueError) as e:
+            raise ValueError(f"Failed to parse GuardrailResult from text: {text}") from e
+
+
+class Guardrail(ABC):
+    """Abstract base class for guardrails."""
+
+    def __init__(
+        self, name: str, condition: str, target: "TransitionTarget", activation_message: Optional[str] = None
+    ) -> None:
+        self.name = name
+        self.condition = condition
+        self.target = target
+        self.activation_message = (
+            activation_message if activation_message else f"Guardrail '{name}' has been activated."
+        )
+
+    @abstractmethod
+    def check(
+        self,
+        context: Union[str, list[dict[str, Any]]],
+    ) -> GuardrailResult:
+        """Checks the text against the guardrail and returns a GuardrailResult.
+
+        Args:
+            context (Union[str, list[dict[str, Any]]]): The context to check against the guardrail.
+
+        Returns:
+            GuardrailResult: The result of the guardrail check.
+        """
+        pass
+
+
+class LLMGuardrail(Guardrail):
+    """Guardrail that uses an LLM to check the context."""
+
+    def __init__(
+        self,
+        name: str,
+        condition: str,
+        target: "TransitionTarget",
+        llm_config: "LLMConfig",
+        activation_message: Optional[str] = None,
+    ) -> None:
+        super().__init__(name, condition, target, activation_message)
+
+        if not llm_config:
+            raise ValueError("LLMConfig is required.")
+
+        self.llm_config = llm_config.deepcopy()
+        setattr(self.llm_config, "response_format", GuardrailResult)
+        self.client = OpenAIWrapper(**self.llm_config.model_dump())
+
+        self.check_prompt = f"""You are a guardrail that checks if a condition is met in the conversation you are given.
+You will activate the guardrail only if the condition is met.
+
+**Condition: {self.condition}**"""
+
+    def check(
+        self,
+        context: Union[str, list[dict[str, Any]]],
+    ) -> GuardrailResult:
+        """Checks the context against the guardrail using an LLM.
+
+        Args:
+            context (Union[str, list[dict[str, Any]]]): The context to check against the guardrail.
+
+        Returns:
+            GuardrailResult: The result of the guardrail check.
+        """
+        # Set the check prompt as the system message
+        check_messages = [{"role": "system", "content": self.check_prompt}]
+        # If context is a string, wrap it in a user message and append it
+        if isinstance(context, str):
+            check_messages.append({"role": "user", "content": context})
+        # If context is a list of messages, append them
+        elif isinstance(context, list):
+            check_messages.extend(context)
+        else:
+            raise ValueError("Context must be a string or a list of messages.")
+        # Call the LLM with the check messages
+        response = self.client.create(messages=check_messages)
+        return GuardrailResult.parse(response.choices[0].message.content)  # type: ignore
+
+
+class RegexGuardrail(Guardrail):
+    """Guardrail that checks the context against a regular expression."""
+
+    def __init__(
+        self,
+        name: str,
+        condition: str,
+        target: "TransitionTarget",
+        activation_message: Optional[str] = None,
+    ) -> None:
+        super().__init__(name, condition, target, activation_message)
+        # Compile the regular expression condition
+        try:
+            self.regex = re.compile(condition)
+        except re.error as e:
+            raise ValueError(f"Invalid regex pattern '{condition}': {str(e)}")
+
+    def check(
+        self,
+        context: Union[str, list[dict[str, Any]]],
+    ) -> GuardrailResult:
+        """Checks the context against the guardrail using a regular expression.
+
+        Args:
+            context (Union[str, list[dict[str, Any]]]): The context to check against the guardrail.
+
+        Returns:
+            GuardrailResult: The result of the guardrail check.
+        """
+        # Create a list of the messages to check
+        if isinstance(context, str):
+            messages = [context]
+        elif isinstance(context, list):
+            messages = [message.get("content", "") for message in context]
+        else:
+            raise ValueError("Context must be a string or a list of messages.")
+
+        # Check each message against the regex
+        for message in messages:
+            match = self.regex.search(message)
+            # If a match is found, activate the guardrail and return the result
+            if match:
+                activated = True
+                justification = f"Match found -> {match.group(0)}"
+                return GuardrailResult(activated=activated, justification=justification)
+        return GuardrailResult(activated=False, justification="No match found in the context.")

autogen/agentchat/group/handoffs.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Optional, Union, overload
+from typing import Union, overload
 
 from pydantic import BaseModel, Field
 
@@ -30,7 +30,7 @@ class Handoffs(BaseModel):
 
     context_conditions: list[OnContextCondition] = Field(default_factory=list)
     llm_conditions: list[OnCondition] = Field(default_factory=list)
-    after_work: Optional[TransitionTarget] = None
+    after_works: list[OnContextCondition] = Field(default_factory=list)
 
     def add_context_condition(self, condition: OnContextCondition) -> "Handoffs":
         """
@@ -102,7 +102,9 @@ class Handoffs(BaseModel):
 
     def set_after_work(self, target: TransitionTarget) -> "Handoffs":
         """
-        Set the after work target (only one allowed).
+        Set the after work target (replaces all after_works with single entry).
+
+        For backward compatibility, this creates an OnContextCondition with no condition (always true).
 
         Args:
             target: The after work TransitionTarget to set
@@ -113,7 +115,81 @@ class Handoffs(BaseModel):
         if not isinstance(target, TransitionTarget):
             raise TypeError(f"Expected a TransitionTarget instance, got {type(target).__name__}")
 
-        self.after_work = target
+        # Create OnContextCondition with no condition (always true)
+        after_work_condition = OnContextCondition(target=target, condition=None)
+        self.after_works = [after_work_condition]
+        return self
+
+    def add_after_work(self, condition: OnContextCondition) -> "Handoffs":
+        """
+        Add a single after-work condition.
+
+        If the condition has condition=None, it will replace any existing
+        condition=None entry and be placed at the end.
+
+        Args:
+            condition: The OnContextCondition to add
+
+        Returns:
+            Self for method chaining
+        """
+        if not isinstance(condition, OnContextCondition):
+            raise TypeError(f"Expected an OnContextCondition instance, got {type(condition).__name__}")
+
+        if condition.condition is None:
+            # Remove any existing condition=None entries
+            self.after_works = [c for c in self.after_works if c.condition is not None]
+            # Add the new one at the end
+            self.after_works.append(condition)
+        else:
+            # For regular conditions, check if we need to move condition=None to the end
+            none_conditions = [c for c in self.after_works if c.condition is None]
+            if none_conditions:
+                # Remove the None condition temporarily
+                self.after_works = [c for c in self.after_works if c.condition is not None]
+                # Add the new regular condition
+                self.after_works.append(condition)
+                # Re-add the None condition at the end
+                self.after_works.append(none_conditions[0])
+            else:
+                # No None condition exists, just append
+                self.after_works.append(condition)
+
+        return self
+
+    def add_after_works(self, conditions: list[OnContextCondition]) -> "Handoffs":
+        """
+        Add multiple after-work conditions.
+
+        Special handling for condition=None entries:
+        - Only one condition=None entry is allowed (the fallback)
+        - It will always be placed at the end of the list
+        - If multiple condition=None entries are provided, only the last one is kept
+
+        Args:
+            conditions: List of OnContextConditions to add
+
+        Returns:
+            Self for method chaining
+        """
+        # Validate that it is a list of OnContextConditions
+        if not all(isinstance(condition, OnContextCondition) for condition in conditions):
+            raise TypeError("All conditions must be of type OnContextCondition")
+
+        # Separate conditions with None and without None
+        none_conditions = [c for c in conditions if c.condition is None]
+        regular_conditions = [c for c in conditions if c.condition is not None]
+
+        # Remove any existing condition=None entries
+        self.after_works = [c for c in self.after_works if c.condition is not None]
+
+        # Add regular conditions
+        self.after_works.extend(regular_conditions)
+
+        # Add at most one None condition at the end
+        if none_conditions:
+            self.after_works.append(none_conditions[-1])  # Use the last one if multiple provided
+
         return self
 
     @overload
@@ -186,7 +262,7 @@ class Handoffs(BaseModel):
         """
         self.context_conditions.clear()
         self.llm_conditions.clear()
-        self.after_work = None
+        self.after_works.clear()
         return self
 
     def get_llm_conditions_by_target_type(self, target_type: type) -> list[OnCondition]:

autogen/agentchat/group/on_context_condition.py

@@ -24,12 +24,12 @@ class OnContextCondition(BaseModel):  # noqa: N801
 
     Args:
         target (TransitionTarget): The transition (essentially an agent) to hand off to.
-        condition (ContextCondition): The context variable based condition for transitioning to the target agent.
+        condition (Optional[ContextCondition]): The context variable based condition for transitioning to the target agent. If None, the condition always evaluates to True.
         available (AvailableCondition): Optional condition to determine if this OnCondition is included for the LLM to evaluate based on context variables using classes like StringAvailableCondition and ContextExpressionAvailableCondition.
     """
 
     target: TransitionTarget
-    condition: ContextCondition
+    condition: Optional[ContextCondition] = None
     available: Optional[AvailableCondition] = None
 
     def has_target_type(self, target_type: type) -> bool:

autogen/agentchat/group/patterns/pattern.py

@@ -152,7 +152,13 @@ class Pattern(ABC):
         manager = create_group_manager(groupchat, self.group_manager_args, self.agents, self.group_after_work)
 
         # Point all agent's context variables to this function's context_variables
-        setup_context_variables(tool_executor, self.agents, manager, self.context_variables)
+        setup_context_variables(
+            tool_execution=tool_executor,
+            agents=self.agents,
+            manager=manager,
+            user_agent=self.user_agent,
+            context_variables=self.context_variables,
+        )
 
         # Link all agents with the GroupChatManager to allow access to the group chat
         link_agents_to_group_manager(groupchat.agents, manager)

autogen/agentchat/group/targets/transition_target.py

@@ -68,6 +68,16 @@ class TransitionTarget(BaseModel):
         """Create a wrapper agent for the target if needed."""
         raise NotImplementedError("Requires subclasses to implement.")
 
+    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"""
+        for agent in groupchat.agents:  # type: ignore[attr-defined]
+            # get the GroupToolExecutor agent
+            if type(agent).__name__ == "GroupToolExecutor":
+                agent.set_next_target(self)  # type: ignore[attr-defined]
+                return
+
 
 class AgentTarget(TransitionTarget):
     """Target that represents a direct agent reference."""

autogen/agentchat/groupchat.py

@@ -1023,6 +1023,38 @@ class GroupChat:
                 mentions[agent.name] = count
         return mentions
 
+    def _run_input_guardrails(
+        self,
+        agent: "ConversableAgent",
+        messages: Optional[list[dict[str, Any]]] = None,
+    ) -> Optional[str]:
+        """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.
+        """
+        for guardrail in agent.input_guardrails:
+            guardrail_result = guardrail.check(context=messages)
+
+            if guardrail_result.activated:
+                guardrail.target.activate_target(self)
+                return f"{guardrail.activation_message}\nJustification: {guardrail_result.justification}"
+        return None
+
+    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.
+        """
+        for guardrail in agent.output_guardrails:
+            guardrail_result = guardrail.check(context=reply)
+
+            if guardrail_result.activated:
+                guardrail.target.activate_target(self)
+                return f"{guardrail.activation_message}\nJustification: {guardrail_result.justification}"
+        return None
+
 
 @export_module("autogen")
 class GroupChatManager(ConversableAgent):
@@ -1194,8 +1226,17 @@ class GroupChatManager(ConversableAgent):
                 if not silent:
                     iostream = IOStream.get_default()
                     iostream.send(GroupChatRunChatEvent(speaker=speaker, silent=silent))
-                # let the speaker speak
-                reply = speaker.generate_reply(sender=self)
+
+                guardrails_activated = False
+                guardrails_reply = groupchat._run_input_guardrails(speaker, speaker._oai_messages[self])
+
+                if guardrails_reply is not None:
+                    # if a guardrail has been activated, then the next target has been set and the guardrail reply will be sent
+                    guardrails_activated = True
+                    reply = guardrails_reply
+                else:
+                    # let the speaker speak
+                    reply = speaker.generate_reply(sender=self)
             except KeyboardInterrupt:
                 # let the admin agent speak if interrupted
                 if groupchat.admin_name in groupchat.agent_names:
@@ -1215,6 +1256,15 @@ class GroupChatManager(ConversableAgent):
                 termination_reason = "No reply generated"
                 break
 
+            if not guardrails_activated:
+                # if the input guardrails were not activated, and the agent returned a reply
+                guardrails_reply = groupchat._run_output_guardrails(speaker, reply)
+
+                if guardrails_reply is not None:
+                    # if a guardrail has been activated, then the next target has been set and the guardrail reply will be sent
+                    guardrails_activated = True
+                    reply = guardrails_reply
+
             # check for "clear history" phrase in reply and activate clear history function if found
             if (
                 groupchat.enable_clear_history
@@ -1233,7 +1283,11 @@ class GroupChatManager(ConversableAgent):
                 a.previous_cache = None
 
         if termination_reason:
-            iostream.send(TerminationEvent(termination_reason=termination_reason))
+            iostream.send(
+                TerminationEvent(
+                    termination_reason=termination_reason, sender=self, recipient=speaker if speaker else None
+                )
+            )
 
         return True, None
 
@@ -1287,8 +1341,19 @@ class GroupChatManager(ConversableAgent):
             try:
                 # select the next speaker
                 speaker = await groupchat.a_select_speaker(speaker, self)
-                # let the speaker speak
-                reply = await speaker.a_generate_reply(sender=self)
+                if not silent:
+                    iostream.send(GroupChatRunChatEvent(speaker=speaker, silent=silent))
+
+                guardrails_activated = False
+                guardrails_reply = groupchat._run_input_guardrails(speaker, speaker._oai_messages[self])
+
+                if guardrails_reply is not None:
+                    # if a guardrail has been activated, then the next target has been set and the guardrail reply will be sent
+                    guardrails_activated = True
+                    reply = guardrails_reply
+                else:
+                    # let the speaker speak
+                    reply = await speaker.a_generate_reply(sender=self)
             except KeyboardInterrupt:
                 # let the admin agent speak if interrupted
                 if groupchat.admin_name in groupchat.agent_names:
@@ -1308,6 +1373,24 @@ class GroupChatManager(ConversableAgent):
                 termination_reason = "No reply generated"
                 break
 
+            if not guardrails_activated:
+                # if the input guardrails were not activated, and the agent returned a reply
+                guardrails_reply = groupchat._run_output_guardrails(speaker, reply)
+
+                if guardrails_reply is not None:
+                    # if a guardrail has been activated, then the next target has been set and the guardrail reply will be sent
+                    guardrails_activated = True
+                    reply = guardrails_reply
+
+            # check for "clear history" phrase in reply and activate clear history function if found
+            if (
+                groupchat.enable_clear_history
+                and isinstance(reply, dict)
+                and reply["content"]
+                and "CLEAR HISTORY" in reply["content"].upper()
+            ):
+                reply["content"] = self.clear_agents_history(reply, groupchat)
+
             # The speaker sends the message without requesting a reply
             await speaker.a_send(reply, self, request_reply=False, silent=silent)
             message = self.last_message(speaker)
@@ -1317,7 +1400,11 @@ class GroupChatManager(ConversableAgent):
                 a.previous_cache = None
 
         if termination_reason:
-            iostream.send(TerminationEvent(termination_reason=termination_reason))
+            iostream.send(
+                TerminationEvent(
+                    termination_reason=termination_reason, sender=self, recipient=speaker if speaker else None
+                )
+            )
 
         return True, None
 
@@ -1489,10 +1576,10 @@ class GroupChatManager(ConversableAgent):
                 for agent in self._groupchat.agents:
                     if agent.name == message["name"]:
                         # An agent`s message is sent to the Group Chat Manager
-                        agent.a_send(message, self, request_reply=False, silent=True)
+                        await agent.a_send(message, self, request_reply=False, silent=True)
                     else:
                         # Otherwise, messages are sent from the Group Chat Manager to the agent
-                        self.a_send(message, agent, request_reply=False, silent=True)
+                        await self.a_send(message, agent, request_reply=False, silent=True)
 
                 # Add previous message to the new groupchat, if it's an admin message the name may not match so add the message directly
                 if message_speaker_agent: