Graph group chat

.github/workflows/contrib-openai.yml

@@ -4,7 +4,7 @@
 name: OpenAI4ContribTests
 
 on:
-  pull_request_target:
+  pull_request:
     branches: ['main']
     paths:
       - 'autogen/**'

autogen/agentchat/groupchat.py

@@ -2,16 +2,27 @@
 import random
 import re
 import sys
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Union, Tuple
 
+
 from ..code_utils import content_str
 from .agent import Agent
 from .conversable_agent import ConversableAgent
+from ..graph_utils import check_graph_validity, invert_disallowed_to_allowed, has_self_loops
+
 
 logger = logging.getLogger(__name__)
 
 
+class NoEligibleSpeakerException(Exception):
+    """Exception raised for early termination of a GroupChat."""
+
+    def __init__(self, message="No eligible speakers."):
+        self.message = message
+        super().__init__(self.message)
+
+
 @dataclass
 class GroupChat:
     """(In preview) A group chat class that contains the following data fields:
@@ -30,7 +41,9 @@ class GroupChat:
         - "manual": the next speaker is selected manually by user input.
         - "random": the next speaker is selected randomly.
         - "round_robin": the next speaker is selected in a round robin fashion, i.e., iterating in the same order as provided in `agents`.
-    - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. If allow_repeat_speaker is a list of Agents, then only those listed agents are allowed to repeat. If set to False, then no speakers are allowed to repeat.
+    - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is None, which is defaulted to True if allowed_or_disallowed_speaker_order is None, in which case all speakers are allowed to speak consecutively. If allow_repeat_speaker is a list of Agents, then only those listed agents are allowed to repeat. If set to False, then no speakers are allowed to repeat. allow_repeat_speaker and allowed_or_disallowed_speaker_order are mutually exclusive.
+    - allowed_or_disallowed_speaker_order: a dictionary of keys and list as values. The keys are the names of the agents, and the values are the agents that the key agent can transition to. Default is None, in which case a fully connected allowed_speaker_order_dict is assumed. allow_repeat_speaker and allowed_or_disallowed_speaker_order are mutually exclusive.
+    - speaker_order_type: whether the speaker_order_type is a dictionary containing lists of allowed agents or disallowed agents. allowed means the allowed_or_disallowed_speaker_order is a dictionary containing lists of allowed agents. If set to disallowed, then the allowed_or_disallowed_speaker_order is a dictionary containing lists of disallowed agents. Must be supplied if allowed_or_disallowed_speaker_order is not None.
     """
 
     agents: List[Agent]
@@ -39,9 +52,93 @@ class GroupChat:
     admin_name: Optional[str] = "Admin"
     func_call_filter: Optional[bool] = True
     speaker_selection_method: Optional[str] = "auto"
-    allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = True
+    allow_repeat_speaker: Optional[
+        Union[bool, List[Agent]]
+    ] = None  # It would be set to True if allowed_or_disallowed_speaker_order is None
+    allowed_or_disallowed_speaker_order: Optional[Dict] = None
+    speaker_order_type: Optional[str] = None
 
     _VALID_SPEAKER_SELECTION_METHODS = ["auto", "manual", "random", "round_robin"]
+    _VALID_SPEAKER_ORDER_TYPE = ["allowed", "disallowed", None]
+
+    allowed_speaker_order_dict: Dict = field(init=False)
+
+    def __post_init__(self):
+        # Post init steers clears of the automatically generated __init__ method from dataclass
+        # Here, we create allowed_speaker_order_dict from the supplied allowed_or_disallowed_speaker_order and is_allowed_graph, and lastly checks for validity.
+
+        # Check input
+        if self.speaker_order_type is not None:
+            self.speaker_order_type = self.speaker_order_type.lower()
+
+        assert self.speaker_order_type in self._VALID_SPEAKER_ORDER_TYPE, (
+            f"GroupChat speaker_order_type is set to '{self.speaker_order_type}'. "
+            f"It should be one of {self._VALID_SPEAKER_ORDER_TYPE} (case insensitive). "
+        )
+
+        # If both self.allowed_or_disallowed_speaker_order is None and self.allow_repeat_speaker is None, set allow_repeat_speaker to True to ensure backward compatibility
+        # Discussed in https://github.com/microsoft/autogen/pull/857#discussion_r1451541204
+        if self.allowed_or_disallowed_speaker_order is None and self.allow_repeat_speaker is None:
+            self.allow_repeat_speaker = True
+
+        # self.allowed_or_disallowed_speaker_order and self.allow_repeat_speaker are mutually exclusive parameters.
+        # Discussed in https://github.com/microsoft/autogen/pull/857#discussion_r1451266661
+        if self.allowed_or_disallowed_speaker_order is not None and self.allow_repeat_speaker is not None:
+            raise ValueError(
+                "GroupChat allowed_or_disallowed_speaker_order and allow_repeat_speaker cannot both be not None. "
+                "Please set one of them to None."
+            )
+
+        # Asks the user to specify whether the speaker_order_type is allowed or disallowed if speaker_order_type is supplied
+        # Discussed in https://github.com/microsoft/autogen/pull/857#discussion_r1451259524
+        if self.allowed_or_disallowed_speaker_order is not None and self.allowed_or_disallowed_speaker_order is None:
+            raise ValueError(
+                "GroupChat allowed_or_disallowed_speaker_order is not None, but speaker_order_type is None. "
+                "Please set speaker_order_type to either 'allowed' or 'disallowed'."
+            )
+
+        # Inferring self.allowed_speaker_order_dict
+        # Create self.allowed_speaker_order_dict if allowed_or_disallowed_speaker_order is None, using allow_repeat_speaker
+        if self.allowed_or_disallowed_speaker_order is None:
+            self.allowed_speaker_order_dict = {}
+
+            # Create a fully connected allowed_speaker_order_dict not including self loops
+            for agent in self.agents:
+                self.allowed_speaker_order_dict[agent.name] = [
+                    other_agent for other_agent in self.agents if other_agent != agent
+                ]
+
+            # If self.allow_repeat_speaker is True, add self loops to all agents
+            if self.allow_repeat_speaker:
+                for agent in self.agents:
+                    self.allowed_speaker_order_dict[agent.name].append(agent)
+
+            # Else if self.allow_repeat_speaker is a list of Agents, add self loops to the agents in the list
+            elif isinstance(self.allow_repeat_speaker, list):
+                for agent in self.allow_repeat_speaker:
+                    self.allowed_speaker_order_dict[agent.name].append(agent)
+
+        # Create self.allowed_speaker_order_dict if allowed_or_disallowed_speaker_order is not None, using allowed_or_disallowed_speaker_order
+        elif self.allowed_or_disallowed_speaker_order is not None:
+            # Process based on is_allowed_graph
+            if self.speaker_order_type == "allowed":
+                self.allowed_speaker_order_dict = self.allowed_or_disallowed_speaker_order
+            elif self.speaker_order_type == "disallowed":
+                # Logic for processing disallowed allowed_or_disallowed_speaker_order to allowed_speaker_order_dict
+                self.allowed_speaker_order_dict = invert_disallowed_to_allowed(
+                    self.allowed_or_disallowed_speaker_order, self.agents
+                )
+
+        # Inferring self.allow_repeat_speaker from allowed_speaker_order_dict using has_self_loops
+        if self.allow_repeat_speaker is None:
+            self.allow_repeat_speaker = has_self_loops(self.allowed_speaker_order_dict)
+
+        # Check for validity
+        check_graph_validity(
+            allowed_speaker_order_dict=self.allowed_speaker_order_dict,
+            agents=self.agents,
+            allow_repeat_speaker=self.allow_repeat_speaker,
+        )
 
     @property
     def agent_names(self) -> List[str]:
@@ -132,7 +229,7 @@ def manual_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[A
 
     def _prepare_and_select_agents(
         self, last_speaker: Agent
-    ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]]]:
+    ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]], Optional[List[Dict]]]:
         if self.speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS:
             raise ValueError(
                 f"GroupChat speaker_selection_method is set to '{self.speaker_selection_method}'. "
@@ -194,13 +291,26 @@ def _prepare_and_select_agents(
         # remove the last speaker from the list to avoid selecting the same speaker if allow_repeat_speaker is False
         agents = agents if allow_repeat_speaker else [agent for agent in agents if agent != last_speaker]
 
+        # Filter agents with allowed_speaker_order_dict
+        # if last_speaker.name is not a key in allowed_speaker_order_dict, then no agents are eligible
+        if last_speaker.name not in self.allowed_speaker_order_dict:
+            raise NoEligibleSpeakerException(
+                f"Last speaker {last_speaker.name} is not in the allowed_speaker_order_dict."
+            )
+        else:
+            # Extract agent names from the list of agents
+            graph_eligible_agents_names = [agent.name for agent in self.allowed_speaker_order_dict[last_speaker.name]]
+        # Perform filtering
+        graph_eligible_agents = [agent for agent in agents if agent.name in graph_eligible_agents_names]
+
+        # Use the selected speaker selection method
         select_speaker_messages = None
         if self.speaker_selection_method.lower() == "manual":
-            selected_agent = self.manual_select_speaker(agents)
+            selected_agent = self.manual_select_speaker(graph_eligible_agents)
         elif self.speaker_selection_method.lower() == "round_robin":
-            selected_agent = self.next_agent(last_speaker, agents)
+            selected_agent = self.next_agent(last_speaker, graph_eligible_agents)
         elif self.speaker_selection_method.lower() == "random":
-            selected_agent = random.choice(agents)
+            selected_agent = random.choice(graph_eligible_agents)
         else:
             selected_agent = None
             select_speaker_messages = self.messages.copy()
@@ -210,11 +320,11 @@ def _prepare_and_select_agents(
             if select_speaker_messages[-1].get("tool_calls", False):
                 select_speaker_messages[-1] = dict(select_speaker_messages[-1], tool_calls=None)
             select_speaker_messages = select_speaker_messages + [
-                {"role": "system", "content": self.select_speaker_prompt(agents)}
+                {"role": "system", "content": self.select_speaker_prompt(graph_eligible_agents)}
             ]
-        return selected_agent, agents, select_speaker_messages
+        return selected_agent, graph_eligible_agents, select_speaker_messages
 
-    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
+    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         """Select the next speaker."""
         selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker)
         if selected_agent:
@@ -224,7 +334,7 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
         final, name = selector.generate_oai_reply(messages)
         return self._finalize_speaker(last_speaker, final, name, agents)
 
-    async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
+    async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         """Select the next speaker."""
         selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker)
         if selected_agent:
@@ -372,6 +482,10 @@ def run_chat(
                 else:
                     # admin agent is not found in the participants
                     raise
+            except NoEligibleSpeakerException:
+                # No eligible speaker, terminate the conversation
+                break
+
             if reply is None:
                 break
             # The speaker sends the message without requesting a reply