From a6d5f914c4619536eeb46aa82e9d3a48aa2e77e1 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Thu, 23 Nov 2023 04:31:53 +0000
Subject: [PATCH 01/26] Refactored GroupChat to prepare for GraphGroupChat

---
 autogen/agentchat/groupchat.py | 75 +++++++++++++++++++++-------------
 1 file changed, 47 insertions(+), 28 deletions(-)

diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py
index a59f035fb89e..117f647db042 100644
--- a/autogen/agentchat/groupchat.py
+++ b/autogen/agentchat/groupchat.py
@@ -28,6 +28,7 @@ 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`.
+        - "graph": the next speaker is selected based on a graph. The select_speaker method is overridden by GraphGroupChat.
     - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True.
     """
 
@@ -39,7 +40,7 @@ class GroupChat:
     speaker_selection_method: str = "auto"
     allow_repeat_speaker: bool = True
 
-    _VALID_SPEAKER_SELECTION_METHODS = ["auto", "manual", "random", "round_robin"]
+    _VALID_SPEAKER_SELECTION_METHODS = ["auto", "manual", "random", "round_robin", "graph"]
 
     @property
     def agent_names(self) -> List[str]:
@@ -99,6 +100,40 @@ def manual_select_speaker(self, agents: List[Agent]) -> Agent:
                 print(f"Invalid input. Please enter a number between 1 and {_n_agents}.")
         return None
 
+    def auto_select_speaker(
+        self, agents: List[Agent], last_speaker: Agent, selector: ConversableAgent
+    ) -> (Agent, List[Agent], Agent, ConversableAgent):
+        # Encapsulating select_speaker_auto as a class method, so that it can be reused through inheritance in GraphGroupChat
+        # It returns the selected_agent, agents, last_speaker, and selector so as to preserve the states of the inputs from select_speaker
+        selector.update_system_message(self.select_speaker_msg(agents))
+        final, name = selector.generate_oai_reply(
+            self.messages
+            + [
+                {
+                    "role": "system",
+                    "content": f"Read the above conversation. Then select the next role from {[agent.name for agent in agents]} to play. Only return the role.",
+                }
+            ]
+        )
+        if not final:
+            # the LLM client is None, thus no reply is generated. Use round robin instead.
+            return self.next_agent(last_speaker, agents), agents, last_speaker, selector
+
+        # If exactly one agent is mentioned, use it. Otherwise, leave the OAI response unmodified
+        mentions = self._mentioned_agents(name, agents)
+        if len(mentions) == 1:
+            name = next(iter(mentions))
+        else:
+            logger.warning(
+                f"GroupChat select_speaker failed to resolve the next speaker's name. This is because the speaker selection OAI call returned:\n{name}"
+            )
+
+        # Return the result
+        try:
+            return self.agent_by_name(name), agents, last_speaker, selector
+        except ValueError:
+            return self.next_agent(last_speaker, agents), agents, last_speaker, selector
+
     def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
         """Select the next speaker."""
         if self.speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS:
@@ -109,6 +144,7 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
 
         agents = self.agents
         n_agents = len(agents)
+
         # Warn if GroupChat is underpopulated
         if n_agents < 2:
             raise ValueError(
@@ -148,40 +184,23 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
             selected_agent = self.manual_select_speaker(agents)
             if selected_agent:
                 return selected_agent
+
         elif self.speaker_selection_method.lower() == "round_robin":
             return self.next_agent(last_speaker, agents)
+
         elif self.speaker_selection_method.lower() == "random":
             return random.choice(agents)
 
-        # auto speaker selection
-        selector.update_system_message(self.select_speaker_msg(agents))
-        final, name = selector.generate_oai_reply(
-            self.messages
-            + [
-                {
-                    "role": "system",
-                    "content": f"Read the above conversation. Then select the next role from {[agent.name for agent in agents]} to play. Only return the role.",
-                }
-            ]
-        )
-        if not final:
-            # the LLM client is None, thus no reply is generated. Use round robin instead.
-            return self.next_agent(last_speaker, agents)
-
-        # If exactly one agent is mentioned, use it. Otherwise, leave the OAI response unmodified
-        mentions = self._mentioned_agents(name, agents)
-        if len(mentions) == 1:
-            name = next(iter(mentions))
-        else:
-            logger.warning(
-                f"GroupChat select_speaker failed to resolve the next speaker's name. This is because the speaker selection OAI call returned:\n{name}"
+        elif self.speaker_selection_method.lower() == "graph":
+            # This should not trigger because GraphGroupChat select_speaker overrides GroupChat select_speaker
+            raise ValueError(
+                f"GroupChat speaker_selection_method is set to '{self.speaker_selection_method}'. "
+                f"GraphGroupChat select_speaker overrides GroupChat select_speaker. "
             )
 
-        # Return the result
-        try:
-            return self.agent_by_name(name)
-        except ValueError:
-            return self.next_agent(last_speaker, agents)
+        # Since it is not manual nor round_robin nor random, it must be auto
+        auto_selected_speaker, agents, last_speaker, selector = self.auto_select_speaker(agents, last_speaker, selector)
+        return auto_selected_speaker
 
     def _participant_roles(self, agents: List[Agent] = None) -> str:
         # Default to all agents registered

From a26dde7a376fdf06336357932e9bcfcc56279a28 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Thu, 23 Nov 2023 04:32:17 +0000
Subject: [PATCH 02/26] Added two unit test to test the refactoring

---
 test/agentchat/test_groupchat.py | 71 +++++++++++++++++++++++++++++++-
 1 file changed, 69 insertions(+), 2 deletions(-)

diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py
index 441dcb7c6251..fcfa1abb7e2a 100644
--- a/test/agentchat/test_groupchat.py
+++ b/test/agentchat/test_groupchat.py
@@ -5,6 +5,72 @@
 import json
 
 
+def test_groupchat_auto_select_speaker_func_call():
+    agent1 = autogen.ConversableAgent(
+        "alice",
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is alice speaking.",
+    )
+    agent2 = autogen.ConversableAgent(
+        "bob",
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is bob speaking.",
+        function_map={"test_func": lambda x: x},
+    )
+    groupchat = autogen.GroupChat(agents=[agent1, agent2], messages=[], max_round=3)
+
+    agents = [agent1, agent2]
+    last_speaker = agent1
+    selector = autogen.GroupChatManager(groupchat=groupchat, llm_config=False)
+
+    # Action
+    selected_speaker, updated_agents, updated_last_speaker, updated_selector = groupchat.auto_select_speaker(
+        agents, last_speaker, selector
+    )
+
+    # Assertion
+    assert selected_speaker in agents
+    assert id(updated_agents) == id(agents)  # Same instances in memory
+    assert id(updated_selector) == id(selector)  # Same instances in memory
+
+    # Only last_speaker is updated
+    assert id(updated_last_speaker) != id(selected_speaker)  # Different instances in memory
+
+
+def test_expect_error_groupchat_graph_select_speaker():
+    # Setup
+    agent1 = autogen.ConversableAgent(
+        "alice",
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is alice speaking.",
+    )
+    agent2 = autogen.ConversableAgent(
+        "bob",
+        human_input_mode="NEVER",
+        llm_config=False,
+        default_auto_reply="This is bob speaking.",
+        function_map={"test_func": lambda x: x},
+    )
+    agents = [agent1, agent2]
+    messages = []
+    max_round = 10
+
+    # Create an instance of GroupChat with the 'graph' speaker selection method
+    group_chat = autogen.GroupChat(
+        agents=agents, messages=messages, max_round=max_round, speaker_selection_method="graph"
+    )
+
+    # Action and Assertion
+    with pytest.raises(ValueError) as excinfo:
+        group_chat.select_speaker(last_speaker=None, selector=None)
+
+    # Check if the error message is as expected
+    assert "GraphGroupChat select_speaker overrides GroupChat select_speaker" in str(excinfo.value)
+
+
 def test_func_call_groupchat():
     agent1 = autogen.ConversableAgent(
         "alice",
@@ -335,6 +401,7 @@ def test_agent_mentions():
     # test_broadcast()
     # test_chat_manager()
     # test_plugin()
-    test_speaker_selection_method()
-    test_n_agents_less_than_3()
+    # test_speaker_selection_method()
+    # test_n_agents_less_than_3()
     # test_agent_mentions()
+    test_groupchat_auto_select_speaker_func_call()

From c7ab5dc502ee0100c4e8993fd7120f689fbc0672 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Thu, 23 Nov 2023 05:41:52 +0000
Subject: [PATCH 03/26] All tests passed

---
 autogen/agentchat/contrib/graphgroupchat.py   | 140 ++++++++++++++++
 test/agentchat/contrib/test_graphgroupchat.py | 155 ++++++++++++++++++
 2 files changed, 295 insertions(+)
 create mode 100644 autogen/agentchat/contrib/graphgroupchat.py
 create mode 100644 test/agentchat/contrib/test_graphgroupchat.py

diff --git a/autogen/agentchat/contrib/graphgroupchat.py b/autogen/agentchat/contrib/graphgroupchat.py
new file mode 100644
index 000000000000..c8e77db41cd2
--- /dev/null
+++ b/autogen/agentchat/contrib/graphgroupchat.py
@@ -0,0 +1,140 @@
+try:
+    import networkx as nx
+    import matplotlib.pyplot as plt
+except ImportError as e:
+    logging.fatal("Failed to import networkx or matplotlib. Try running 'pip install autogen[graphs]'")
+    raise e
+
+import autogen
+import networkx as nx
+from autogen.agentchat.assistant_agent import AssistantAgent
+from autogen.agentchat.groupchat import GroupChat, Agent, ConversableAgent
+
+import random
+from typing import List, Dict
+
+class GraphGroupChat(GroupChat):
+    """(In preview) A group chat class that contains the following data fields:
+    - agents: a list of participating agents.
+    - messages: a list of messages in the group chat.
+    - graph: a networkx graph depicting who are the next speakers available.
+    - max_round: the maximum number of rounds.
+    - admin_name: the name of the admin agent if there is one. Default is "Admin".
+        KeyBoardInterrupt will make the admin agent take over.
+    - func_call_filter: whether to enforce function call filter. Default is True.
+        When set to True and when a message is a function call suggestion,
+        the next speaker will be chosen from an agent which contains the corresponding function name
+        in its `function_map`.
+    - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True.
+    """
+
+    def __init__(self, agents: List[Agent], messages: List[Dict], graph:nx.DiGraph, 
+                 max_round: int = 10, admin_name: str = "Admin", func_call_filter: bool = True, 
+                 allow_repeat_speaker: bool = True):
+        
+        # Inherit from GroupChat, and initialize with the given parameters (except graph)
+        super().__init__(agents=agents, messages=messages, max_round=max_round, admin_name=admin_name, func_call_filter=func_call_filter, 
+                         speaker_selection_method='graph', 
+                         allow_repeat_speaker=allow_repeat_speaker)
+        
+        self.previous_speaker = None  # Keep track of the previous speaker
+        self.graph = graph  # The graph depicting who are the next speakers available
+        
+        # Check that the graph is a DiGraph
+        if not isinstance(self.graph, nx.DiGraph):
+            raise ValueError("The graph must be a networkx DiGraph.")
+        
+        
+        def _check_graph_validity(self):
+            """
+            Check for the following
+            1. The graph has at least one node
+            2. The graph has at least one edge
+            3. The graph has at least one node with 'first_round_speaker' set to True
+            4. If self.allow_repeat_speaker is False, then the graph has no self-loops
+            """
+            
+            # Check 1. The graph has at least one node
+            if len(self.graph.nodes) == 0:
+                raise ValueError("The graph has no nodes.")
+            
+            # Check 2. The graph has at least one edge
+            if len(self.graph.edges) == 0:
+                raise ValueError("The graph has no edges.")
+            
+            # Check 3. The graph has at least one node with 'first_round_speaker' set to True
+            if not any([self.graph.nodes[agent.name].get('first_round_speaker', False) for agent in self.agents]):
+                raise ValueError("The graph has no nodes with 'first_round_speaker' set to True.")
+            
+            # Check 4. If self.allow_repeat_speaker is False, then the graph has no self-loops
+            if not self.allow_repeat_speaker and any([self.graph.has_edge(agent.name, agent.name) for agent in self.agents]):
+                raise ValueError("The graph has self-loops, but self.allow_repeat_speaker is False.")
+            
+        # Run graph check
+        _check_graph_validity(self)
+        
+    # All methods are from the GroupChat class, except for select_speaker
+    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:       
+        self.previous_speaker = last_speaker
+
+        # Check if last message suggests a next speaker
+        last_message = self.messages[-1] if self.messages else None
+        suggested_next = None
+        
+        if last_message:
+            if 'NEXT:' in last_message['content']:
+                suggested_next = last_message['content'].split('NEXT: ')[-1].strip()
+                # Strip full stop and comma
+                suggested_next = suggested_next.replace('.', '').replace(',', '')
+                print(f"Suggested next speaker from the last message: {suggested_next}")
+                    
+
+        # Selecting first round speaker
+        if self.previous_speaker is None and self.graph is not None:
+            eligible_speakers = [agent for agent in self.agents if self.graph.nodes[agent.name].get('first_round_speaker', False)]
+            print('First round eligible speakers:', [speaker.name for speaker in eligible_speakers])
+
+        # Selecting successors of the previous speaker
+        elif self.previous_speaker is not None and self.graph is not None:
+            eligible_speaker_names = [target for target in self.graph.successors(self.previous_speaker.name)]
+            eligible_speakers = [agent for agent in self.agents if agent.name in eligible_speaker_names]
+            print('Eligible speakers based on previous speaker:', eligible_speaker_names)
+
+        else:
+            eligible_speakers = agents
+
+        # Debugging print for the next potential speakers
+        print(f"Eligible speakers based on graph and previous speaker {self.previous_speaker.name if self.previous_speaker else 'None'}: {[speaker.name for speaker in eligible_speakers]}")
+
+        # Three attempts at getting the next_speaker
+        # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
+        # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
+        # 3. Random (catch-all)
+        next_speaker = None
+        
+        if eligible_speakers:
+            print("Selecting from eligible speakers:", [speaker.name for speaker in eligible_speakers])
+            # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
+            if suggested_next in [speaker.name for speaker in eligible_speakers]:
+                print("suggested_next is in eligible_speakers")
+                next_speaker = self.agent_by_name(suggested_next)
+                
+            else:
+                msgs_len = len(self.messages)
+                print(f"msgs_len is now {msgs_len}")
+                if len(self.messages) > 1:
+                    # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
+                    print(f"Using LLM to pick from eligible_speakers: {[speaker.name for speaker in eligible_speakers]}")
+                    next_speaker, self.agents, last_speaker, selector = self.auto_select_speaker(self.agents, last_speaker, selector)
+
+                if next_speaker is None:
+                    # 3. Random (catch-all)
+                    next_speaker = random.choice(eligible_speakers)
+                    
+                
+            print(f"Selected next speaker: {next_speaker.name}")
+
+            return next_speaker
+        else:
+            # Cannot return next_speaker with no eligible speakers
+            raise ValueError("No eligible speakers found based on the graph constraints.")
\ No newline at end of file
diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
new file mode 100644
index 000000000000..40b5608f48f5
--- /dev/null
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -0,0 +1,155 @@
+try:
+    import networkx as nx
+    import matplotlib.pyplot as plt
+    
+
+    skip_test = False
+except ImportError:
+    skip_test = True
+
+from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat
+import pytest
+from unittest import mock
+import builtins
+import autogen
+import json
+import sys
+import os
+import networkx as nx
+import pytest
+from unittest.mock import MagicMock
+import unittest
+from autogen.agentchat.groupchat import GroupChat, Agent, ConversableAgent
+from autogen.agentchat.assistant_agent import AssistantAgent
+
+
+from autogen import Agent
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+from test_assistant_agent import KEY_LOC, OAI_CONFIG_LIST  # noqa: E402
+
+
+config_list = autogen.config_list_from_json(
+    OAI_CONFIG_LIST, file_location=KEY_LOC, filter_dict={"api_type": ["openai"]}
+)
+
+config_list = autogen.config_list_from_json(
+    OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]}
+)
+
+assert len(config_list) > 0
+
+
+
+#@pytest.mark.skipif(
+#    sys.platform in ["darwin", "win32"] or skip_test,
+#    reason="do not run on MacOS or windows or dependency is not installed",
+#)
+
+class TestGraphGroupChatGraphValidity:
+    def test_graph_with_no_nodes(self):
+        agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
+        messages = []
+        graph = nx.DiGraph()
+
+        with pytest.raises(ValueError) as excinfo:
+            GraphGroupChat(agents, messages, graph)
+        assert "The graph has no nodes." in str(excinfo.value)
+        
+        
+    def test_graph_with_no_edges(self):
+        agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
+        messages = []
+        graph = nx.DiGraph()
+        graph.add_node("Agent 1")
+
+        with pytest.raises(ValueError) as excinfo:
+            GraphGroupChat(agents, messages, graph)
+        assert "The graph has no edges." in str(excinfo.value)
+
+
+    def test_graph_with_no_first_round_speaker(self):
+        agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
+        messages = []
+        graph = nx.DiGraph()
+        graph.add_node("Agent 1")
+        graph.add_edge("Agent 1", "Agent 2")
+
+        with pytest.raises(ValueError) as excinfo:
+            GraphGroupChat(agents, messages, graph)
+        assert "The graph has no nodes with 'first_round_speaker' set to True." in str(excinfo.value)
+
+
+    def test_graph_with_self_loops(self):
+        agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
+        messages = []
+        graph = nx.DiGraph()
+        graph.add_node("Agent 1", first_round_speaker=True)
+        graph.add_node("Agent 2", first_round_speaker=False)
+        graph.add_edge("Agent 1", "Agent 1")
+
+        with pytest.raises(ValueError) as excinfo:
+            GraphGroupChat(agents, messages, graph, allow_repeat_speaker=False)
+        assert "The graph has self-loops, but self.allow_repeat_speaker is False." in str(excinfo.value)
+
+
+
+
+
+class TestGraphGroupChatSelectSpeaker:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        # The default config list in notebook.
+        llm_config = {"config_list": config_list, "cache_seed": 100} 
+        
+        # Mock Agents
+        self.agent1 = AssistantAgent(name="alice", llm_config=llm_config)
+        self.agent2 = AssistantAgent(name="bob", llm_config=llm_config)
+        self.agent3 = AssistantAgent(name="charlie", llm_config=llm_config)
+
+        # Mock ConversableAgent Selector
+        self.selector = ConversableAgent(name='selector', llm_config=llm_config)
+        self.selector.generate_oai_reply = MagicMock(return_value=(True, "bob"))
+
+        # Create Graph
+        self.graph = nx.DiGraph()
+        self.graph.add_node(self.agent1.name, first_round_speaker=True)
+        self.graph.add_node(self.agent2.name)
+        self.graph.add_node(self.agent3.name)
+        self.graph.add_edge(self.agent1.name, self.agent2.name)
+        self.graph.add_edge(self.agent1.name, self.agent3.name)
+        self.graph.add_edge(self.agent2.name, self.agent3.name)
+        self.graph.add_edge(self.agent2.name, self.agent1.name)
+        self.graph.add_edge(self.agent3.name, self.agent1.name)
+        self.graph.add_edge(self.agent3.name, self.agent2.name)
+        
+        
+        # Create agents
+        self.agents = [self.agent1, self.agent2, self.agent3]
+
+    def test_select_first_round_speaker(self):
+        chat = GraphGroupChat(self.agents, [], self.graph)
+        selected_speaker = chat.select_speaker(last_speaker=None, selector=self.selector)
+        assert selected_speaker.name == "alice"
+
+    def test_using_suggested_next_speaker(self):
+        chat = GraphGroupChat(self.agents, [{"content": "Some message. NEXT: charlie"}], self.graph)
+        selected_speaker = chat.select_speaker(last_speaker=self.agent1, selector=self.selector)
+        assert selected_speaker.name == "charlie"
+
+    def test_using_llm_to_pick_speaker(self):
+        chat = GraphGroupChat(self.agents, [{"content": "Some message."}], self.graph)
+        selected_speaker = chat.select_speaker(last_speaker=self.agent1, selector=self.selector)
+        assert selected_speaker.name in ('bob', 'charlie')
+
+    def test_random_speaker_selection(self):
+        chat = GraphGroupChat(self.agents, [], self.graph, allow_repeat_speaker=False)
+        chat.previous_speaker = self.agent3
+        # Overridde random.choice to always return agent2
+        with unittest.mock.patch('random.choice', return_value=self.agent2):
+            selected_speaker = chat.select_speaker(last_speaker=self.agent3, selector=self.selector)
+        assert selected_speaker.name == "bob"
+
+
+if __name__ == "__main__":
+    test_graph_with_no_nodes()
\ No newline at end of file

From e3da1609dd3d274b3139779003b04370b8caa8ab Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Thu, 23 Nov 2023 05:51:07 +0000
Subject: [PATCH 04/26] pre-commit pass

---
 autogen/agentchat/contrib/graphgroupchat.py   | 97 +++++++++++--------
 autogen/agentchat/groupchat.py                |  2 +-
 test/agentchat/contrib/test_graphgroupchat.py | 48 +++------
 3 files changed, 76 insertions(+), 71 deletions(-)

diff --git a/autogen/agentchat/contrib/graphgroupchat.py b/autogen/agentchat/contrib/graphgroupchat.py
index c8e77db41cd2..33ed3039674d 100644
--- a/autogen/agentchat/contrib/graphgroupchat.py
+++ b/autogen/agentchat/contrib/graphgroupchat.py
@@ -1,3 +1,5 @@
+import logging
+
 try:
     import networkx as nx
     import matplotlib.pyplot as plt
@@ -6,13 +8,13 @@
     raise e
 
 import autogen
-import networkx as nx
 from autogen.agentchat.assistant_agent import AssistantAgent
 from autogen.agentchat.groupchat import GroupChat, Agent, ConversableAgent
 
 import random
 from typing import List, Dict
 
+
 class GraphGroupChat(GroupChat):
     """(In preview) A group chat class that contains the following data fields:
     - agents: a list of participating agents.
@@ -28,23 +30,34 @@ class GraphGroupChat(GroupChat):
     - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True.
     """
 
-    def __init__(self, agents: List[Agent], messages: List[Dict], graph:nx.DiGraph, 
-                 max_round: int = 10, admin_name: str = "Admin", func_call_filter: bool = True, 
-                 allow_repeat_speaker: bool = True):
-        
+    def __init__(
+        self,
+        agents: List[Agent],
+        messages: List[Dict],
+        graph: nx.DiGraph,
+        max_round: int = 10,
+        admin_name: str = "Admin",
+        func_call_filter: bool = True,
+        allow_repeat_speaker: bool = True,
+    ):
         # Inherit from GroupChat, and initialize with the given parameters (except graph)
-        super().__init__(agents=agents, messages=messages, max_round=max_round, admin_name=admin_name, func_call_filter=func_call_filter, 
-                         speaker_selection_method='graph', 
-                         allow_repeat_speaker=allow_repeat_speaker)
-        
+        super().__init__(
+            agents=agents,
+            messages=messages,
+            max_round=max_round,
+            admin_name=admin_name,
+            func_call_filter=func_call_filter,
+            speaker_selection_method="graph",
+            allow_repeat_speaker=allow_repeat_speaker,
+        )
+
         self.previous_speaker = None  # Keep track of the previous speaker
         self.graph = graph  # The graph depicting who are the next speakers available
-        
+
         # Check that the graph is a DiGraph
         if not isinstance(self.graph, nx.DiGraph):
             raise ValueError("The graph must be a networkx DiGraph.")
-        
-        
+
         def _check_graph_validity(self):
             """
             Check for the following
@@ -53,88 +66,96 @@ def _check_graph_validity(self):
             3. The graph has at least one node with 'first_round_speaker' set to True
             4. If self.allow_repeat_speaker is False, then the graph has no self-loops
             """
-            
+
             # Check 1. The graph has at least one node
             if len(self.graph.nodes) == 0:
                 raise ValueError("The graph has no nodes.")
-            
+
             # Check 2. The graph has at least one edge
             if len(self.graph.edges) == 0:
                 raise ValueError("The graph has no edges.")
-            
+
             # Check 3. The graph has at least one node with 'first_round_speaker' set to True
-            if not any([self.graph.nodes[agent.name].get('first_round_speaker', False) for agent in self.agents]):
+            if not any([self.graph.nodes[agent.name].get("first_round_speaker", False) for agent in self.agents]):
                 raise ValueError("The graph has no nodes with 'first_round_speaker' set to True.")
-            
+
             # Check 4. If self.allow_repeat_speaker is False, then the graph has no self-loops
-            if not self.allow_repeat_speaker and any([self.graph.has_edge(agent.name, agent.name) for agent in self.agents]):
+            if not self.allow_repeat_speaker and any(
+                [self.graph.has_edge(agent.name, agent.name) for agent in self.agents]
+            ):
                 raise ValueError("The graph has self-loops, but self.allow_repeat_speaker is False.")
-            
+
         # Run graph check
         _check_graph_validity(self)
-        
+
     # All methods are from the GroupChat class, except for select_speaker
-    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:       
+    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         self.previous_speaker = last_speaker
 
         # Check if last message suggests a next speaker
         last_message = self.messages[-1] if self.messages else None
         suggested_next = None
-        
+
         if last_message:
-            if 'NEXT:' in last_message['content']:
-                suggested_next = last_message['content'].split('NEXT: ')[-1].strip()
+            if "NEXT:" in last_message["content"]:
+                suggested_next = last_message["content"].split("NEXT: ")[-1].strip()
                 # Strip full stop and comma
-                suggested_next = suggested_next.replace('.', '').replace(',', '')
+                suggested_next = suggested_next.replace(".", "").replace(",", "")
                 print(f"Suggested next speaker from the last message: {suggested_next}")
-                    
 
         # Selecting first round speaker
         if self.previous_speaker is None and self.graph is not None:
-            eligible_speakers = [agent for agent in self.agents if self.graph.nodes[agent.name].get('first_round_speaker', False)]
-            print('First round eligible speakers:', [speaker.name for speaker in eligible_speakers])
+            eligible_speakers = [
+                agent for agent in self.agents if self.graph.nodes[agent.name].get("first_round_speaker", False)
+            ]
+            print("First round eligible speakers:", [speaker.name for speaker in eligible_speakers])
 
         # Selecting successors of the previous speaker
         elif self.previous_speaker is not None and self.graph is not None:
             eligible_speaker_names = [target for target in self.graph.successors(self.previous_speaker.name)]
             eligible_speakers = [agent for agent in self.agents if agent.name in eligible_speaker_names]
-            print('Eligible speakers based on previous speaker:', eligible_speaker_names)
+            print("Eligible speakers based on previous speaker:", eligible_speaker_names)
 
         else:
-            eligible_speakers = agents
+            eligible_speakers = self.agents
 
         # Debugging print for the next potential speakers
-        print(f"Eligible speakers based on graph and previous speaker {self.previous_speaker.name if self.previous_speaker else 'None'}: {[speaker.name for speaker in eligible_speakers]}")
+        print(
+            f"Eligible speakers based on graph and previous speaker {self.previous_speaker.name if self.previous_speaker else 'None'}: {[speaker.name for speaker in eligible_speakers]}"
+        )
 
         # Three attempts at getting the next_speaker
         # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
         # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
         # 3. Random (catch-all)
         next_speaker = None
-        
+
         if eligible_speakers:
             print("Selecting from eligible speakers:", [speaker.name for speaker in eligible_speakers])
             # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
             if suggested_next in [speaker.name for speaker in eligible_speakers]:
                 print("suggested_next is in eligible_speakers")
                 next_speaker = self.agent_by_name(suggested_next)
-                
+
             else:
                 msgs_len = len(self.messages)
                 print(f"msgs_len is now {msgs_len}")
                 if len(self.messages) > 1:
                     # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
-                    print(f"Using LLM to pick from eligible_speakers: {[speaker.name for speaker in eligible_speakers]}")
-                    next_speaker, self.agents, last_speaker, selector = self.auto_select_speaker(self.agents, last_speaker, selector)
+                    print(
+                        f"Using LLM to pick from eligible_speakers: {[speaker.name for speaker in eligible_speakers]}"
+                    )
+                    next_speaker, self.agents, last_speaker, selector = self.auto_select_speaker(
+                        self.agents, last_speaker, selector
+                    )
 
                 if next_speaker is None:
                     # 3. Random (catch-all)
                     next_speaker = random.choice(eligible_speakers)
-                    
-                
+
             print(f"Selected next speaker: {next_speaker.name}")
 
             return next_speaker
         else:
             # Cannot return next_speaker with no eligible speakers
-            raise ValueError("No eligible speakers found based on the graph constraints.")
\ No newline at end of file
+            raise ValueError("No eligible speakers found based on the graph constraints.")
diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py
index 117f647db042..1c1e9e3da018 100644
--- a/autogen/agentchat/groupchat.py
+++ b/autogen/agentchat/groupchat.py
@@ -134,7 +134,7 @@ def auto_select_speaker(
         except ValueError:
             return self.next_agent(last_speaker, agents), agents, last_speaker, selector
 
-    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent):
+    def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent:
         """Select the next speaker."""
         if self.speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS:
             raise ValueError(
diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 40b5608f48f5..03bd585c172a 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -1,21 +1,18 @@
 try:
     import networkx as nx
     import matplotlib.pyplot as plt
-    
 
     skip_test = False
 except ImportError:
     skip_test = True
 
 from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat
-import pytest
 from unittest import mock
 import builtins
 import autogen
 import json
 import sys
 import os
-import networkx as nx
 import pytest
 from unittest.mock import MagicMock
 import unittest
@@ -23,8 +20,6 @@
 from autogen.agentchat.assistant_agent import AssistantAgent
 
 
-from autogen import Agent
-
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 from test_assistant_agent import KEY_LOC, OAI_CONFIG_LIST  # noqa: E402
 
@@ -33,19 +28,15 @@
     OAI_CONFIG_LIST, file_location=KEY_LOC, filter_dict={"api_type": ["openai"]}
 )
 
-config_list = autogen.config_list_from_json(
-    OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]}
-)
+# config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
 
 assert len(config_list) > 0
 
 
-
-#@pytest.mark.skipif(
-#    sys.platform in ["darwin", "win32"] or skip_test,
-#    reason="do not run on MacOS or windows or dependency is not installed",
-#)
-
+@pytest.mark.skipif(
+    sys.platform in ["darwin", "win32"] or skip_test,
+    reason="do not run on MacOS or windows or dependency is not installed",
+)
 class TestGraphGroupChatGraphValidity:
     def test_graph_with_no_nodes(self):
         agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
@@ -55,8 +46,7 @@ def test_graph_with_no_nodes(self):
         with pytest.raises(ValueError) as excinfo:
             GraphGroupChat(agents, messages, graph)
         assert "The graph has no nodes." in str(excinfo.value)
-        
-        
+
     def test_graph_with_no_edges(self):
         agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
         messages = []
@@ -67,7 +57,6 @@ def test_graph_with_no_edges(self):
             GraphGroupChat(agents, messages, graph)
         assert "The graph has no edges." in str(excinfo.value)
 
-
     def test_graph_with_no_first_round_speaker(self):
         agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
         messages = []
@@ -79,7 +68,6 @@ def test_graph_with_no_first_round_speaker(self):
             GraphGroupChat(agents, messages, graph)
         assert "The graph has no nodes with 'first_round_speaker' set to True." in str(excinfo.value)
 
-
     def test_graph_with_self_loops(self):
         agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
         messages = []
@@ -93,22 +81,23 @@ def test_graph_with_self_loops(self):
         assert "The graph has self-loops, but self.allow_repeat_speaker is False." in str(excinfo.value)
 
 
-
-
-
+@pytest.mark.skipif(
+    sys.platform in ["darwin", "win32"] or skip_test,
+    reason="do not run on MacOS or windows or dependency is not installed",
+)
 class TestGraphGroupChatSelectSpeaker:
     @pytest.fixture(autouse=True)
     def setup(self):
         # The default config list in notebook.
-        llm_config = {"config_list": config_list, "cache_seed": 100} 
-        
+        llm_config = {"config_list": config_list, "cache_seed": 100}
+
         # Mock Agents
         self.agent1 = AssistantAgent(name="alice", llm_config=llm_config)
         self.agent2 = AssistantAgent(name="bob", llm_config=llm_config)
         self.agent3 = AssistantAgent(name="charlie", llm_config=llm_config)
 
         # Mock ConversableAgent Selector
-        self.selector = ConversableAgent(name='selector', llm_config=llm_config)
+        self.selector = ConversableAgent(name="selector", llm_config=llm_config)
         self.selector.generate_oai_reply = MagicMock(return_value=(True, "bob"))
 
         # Create Graph
@@ -122,8 +111,7 @@ def setup(self):
         self.graph.add_edge(self.agent2.name, self.agent1.name)
         self.graph.add_edge(self.agent3.name, self.agent1.name)
         self.graph.add_edge(self.agent3.name, self.agent2.name)
-        
-        
+
         # Create agents
         self.agents = [self.agent1, self.agent2, self.agent3]
 
@@ -140,16 +128,12 @@ def test_using_suggested_next_speaker(self):
     def test_using_llm_to_pick_speaker(self):
         chat = GraphGroupChat(self.agents, [{"content": "Some message."}], self.graph)
         selected_speaker = chat.select_speaker(last_speaker=self.agent1, selector=self.selector)
-        assert selected_speaker.name in ('bob', 'charlie')
+        assert selected_speaker.name in ("bob", "charlie")
 
     def test_random_speaker_selection(self):
         chat = GraphGroupChat(self.agents, [], self.graph, allow_repeat_speaker=False)
         chat.previous_speaker = self.agent3
         # Overridde random.choice to always return agent2
-        with unittest.mock.patch('random.choice', return_value=self.agent2):
+        with unittest.mock.patch("random.choice", return_value=self.agent2):
             selected_speaker = chat.select_speaker(last_speaker=self.agent3, selector=self.selector)
         assert selected_speaker.name == "bob"
-
-
-if __name__ == "__main__":
-    test_graph_with_no_nodes()
\ No newline at end of file

From faf442fe9814d278641b6c67ab2ca76286a1e167 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 00:35:12 +0000
Subject: [PATCH 05/26] improved _check_graph_validity

---
 autogen/agentchat/contrib/graphgroupchat.py | 34 ++++++++++++---------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/autogen/agentchat/contrib/graphgroupchat.py b/autogen/agentchat/contrib/graphgroupchat.py
index 33ed3039674d..f515ee648ce4 100644
--- a/autogen/agentchat/contrib/graphgroupchat.py
+++ b/autogen/agentchat/contrib/graphgroupchat.py
@@ -65,6 +65,8 @@ def _check_graph_validity(self):
             2. The graph has at least one edge
             3. The graph has at least one node with 'first_round_speaker' set to True
             4. If self.allow_repeat_speaker is False, then the graph has no self-loops
+            5. Warning if there are isolated agent nodes
+            6. Warning if there are any agents in self.agents not in graph
             """
 
             # Check 1. The graph has at least one node
@@ -76,7 +78,8 @@ def _check_graph_validity(self):
                 raise ValueError("The graph has no edges.")
 
             # Check 3. The graph has at least one node with 'first_round_speaker' set to True
-            if not any([self.graph.nodes[agent.name].get("first_round_speaker", False) for agent in self.agents]):
+            first_round_speakers = [agent for agent in self.agents if agent.name in self.graph.nodes and self.graph.nodes[agent.name].get("first_round_speaker", False)]
+            if not first_round_speakers:
                 raise ValueError("The graph has no nodes with 'first_round_speaker' set to True.")
 
             # Check 4. If self.allow_repeat_speaker is False, then the graph has no self-loops
@@ -84,6 +87,20 @@ def _check_graph_validity(self):
                 [self.graph.has_edge(agent.name, agent.name) for agent in self.agents]
             ):
                 raise ValueError("The graph has self-loops, but self.allow_repeat_speaker is False.")
+            
+            # Check 5. Warning if there are isolated agent nodes
+            if any([self.graph.degree(agent.name) == 0 for agent in self.agents]):
+                # Name the isolated agents
+                isolated_agents = [agent.name for agent in self.agents if self.graph.degree(agent.name) == 0]
+                logging.warning(f"The graph has isolated agents: {isolated_agents}")
+                
+            # Check 6. Warning if there are any agents in self.agents not in graph
+            if any([agent.name not in self.graph.nodes for agent in self.agents]):
+                # Name the agents not in the graph
+                agents_not_in_graph = [agent.name for agent in self.agents if agent.name not in self.graph.nodes]
+                logging.warning(f"The graph has agents not in self.agents: {agents_not_in_graph}")
+                
+                
 
         # Run graph check
         _check_graph_validity(self)
@@ -101,28 +118,22 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age
                 suggested_next = last_message["content"].split("NEXT: ")[-1].strip()
                 # Strip full stop and comma
                 suggested_next = suggested_next.replace(".", "").replace(",", "")
-                print(f"Suggested next speaker from the last message: {suggested_next}")
 
         # Selecting first round speaker
         if self.previous_speaker is None and self.graph is not None:
             eligible_speakers = [
                 agent for agent in self.agents if self.graph.nodes[agent.name].get("first_round_speaker", False)
             ]
-            print("First round eligible speakers:", [speaker.name for speaker in eligible_speakers])
 
         # Selecting successors of the previous speaker
         elif self.previous_speaker is not None and self.graph is not None:
             eligible_speaker_names = [target for target in self.graph.successors(self.previous_speaker.name)]
             eligible_speakers = [agent for agent in self.agents if agent.name in eligible_speaker_names]
-            print("Eligible speakers based on previous speaker:", eligible_speaker_names)
 
         else:
             eligible_speakers = self.agents
 
-        # Debugging print for the next potential speakers
-        print(
-            f"Eligible speakers based on graph and previous speaker {self.previous_speaker.name if self.previous_speaker else 'None'}: {[speaker.name for speaker in eligible_speakers]}"
-        )
+        
 
         # Three attempts at getting the next_speaker
         # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
@@ -131,20 +142,14 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age
         next_speaker = None
 
         if eligible_speakers:
-            print("Selecting from eligible speakers:", [speaker.name for speaker in eligible_speakers])
             # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
             if suggested_next in [speaker.name for speaker in eligible_speakers]:
-                print("suggested_next is in eligible_speakers")
                 next_speaker = self.agent_by_name(suggested_next)
 
             else:
                 msgs_len = len(self.messages)
-                print(f"msgs_len is now {msgs_len}")
                 if len(self.messages) > 1:
                     # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
-                    print(
-                        f"Using LLM to pick from eligible_speakers: {[speaker.name for speaker in eligible_speakers]}"
-                    )
                     next_speaker, self.agents, last_speaker, selector = self.auto_select_speaker(
                         self.agents, last_speaker, selector
                     )
@@ -153,7 +158,6 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age
                     # 3. Random (catch-all)
                     next_speaker = random.choice(eligible_speakers)
 
-            print(f"Selected next speaker: {next_speaker.name}")
 
             return next_speaker
         else:

From aab6be9d24b239d44f5d5062a46750b25d7ddfb4 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 00:35:39 +0000
Subject: [PATCH 06/26] More tests

---
 ...elling_language_using_select_speaker.ipynb | 446 ++++++++----------
 test/agentchat/contrib/test_graphgroupchat.py | 129 ++++-
 2 files changed, 314 insertions(+), 261 deletions(-)

diff --git a/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb b/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb
index bbe487f419b0..c7a020211778 100644
--- a/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb
+++ b/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb
@@ -87,7 +87,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -127,7 +127,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABbyUlEQVR4nO3deViU9f4+8JthU3BJUBRSEARJAXcC1FxYNAFBBMMdCZc0c+vY4jmZtlmd+FnSam65lYaZpphZoYkKKsrqhgsg4gDDgOzLMPz+qPzmccUZ+Mxyv67rXJcwM8/cdBRu3p/n+TwGjY2NjSAiIiIiekwS0QGIiIiISLuxUBIRERGRSlgoiYiIiEglLJREREREpBIWSiIiIiJSCQslEREREamEhZKIiIiIVMJCSUREREQqYaEkIiIiIpWwUBIRERGRSlgoiYiIiEglLJREREREpBIWSiIiIiJSCQslEREREamEhZKIiIiIVMJCSUREREQqYaEkIiIiIpWwUBIRERGRSlgoiYiIiEglLJREREREpBIWSiIiIiJSCQslEREREamEhZKIiIiIVMJCSUREREQqYaEkIiIiIpWwUBIRERGRSlgoiYiIiEglLJREREREpBIWSiIiIiJSCQslEREREamEhZKIiIiIVMJCSUREREQqYaEkIiIiIpWwUBIRERGRSlgoiYiIiEglLJREREREpBIWSiIiIiJSiZHoAERERER/q6xVILu4EnUKJUyMJOhuaQ5zU9YVTcf/h4iIiEiorIJybEvKRfzFQuTKq9D4j8cMANhamGGksxWmeNjCqXNbUTHpAQwaGxsbH/40IiIiIvW6Lq/Cst3pOHpZBkOJARqU968kfz/+jGNHvBfihm4WZi2YlB6GhZKIiIha3HencvHm3kwolI0PLJL/y1BiACOJAVYGuWCiu20zJqSmYKEkIiKiFvVpfBY++uWSysf516iemD/SSQ2JSFW8ypuIiIhazHenctVSJgHgo18uYcepXLUci1TDCSURERG1iOvyKviuPoJahfKuxxqqy1GWtAu1Ny6g7mYWGhW1AABzVx90DFx832OaGknw6+LhPKdSME4oiYiIqEUs250OxX3Ol2woK0JZYixqr2fcLpOPQqFsxLLd6eqKSI+JhZKIiIiaXVZBOY5elt3/AhxDI5h2c0U7zzCY9/F75OM2KBtx9LIMlwvL1ZSUHgcLJRERETW7bUm5MJQY3Pdxk4626DLlfXQYMQOm1k270MZQYoCtiTyXUiQWSiIiImp28RcLm7Q9UFM0KBsRf6mwWY5Nj4aFkoiIiJpVRa0CufKqZn2P3OIqVNYqmvU96P5YKImIiKhZ5RRXorm3lGkEkF1c2czvQvfDQklERETNqu4e2wRp8/vQ3VgoiYiIqFmZGLVM3Wip96G78b88ERERNavulua4//Xd6mHw1/uQGEaiAxAREZFuMzc1gq2FGXIecGGOsr4G1VdOAwDqCq7e/ryirBCVFxIAAKbWPWHU3uqer7e1NIO5KWuNKPwvT0RERM1upLMVtiTl3HfrIGXlLch+fP+uz9fmpqM298874Vj6L0KbPr53PcdQYoCRPe9dNKllcMmbiIiImt0UD9tm3YdyqqdtsxybHo1BY2Njc1/JT0RERIRp65Nw/GqxWoulocQAgx0ssSXKQ23HpKbjhJKIiIhahHe7QijqatV6TCOJAd4LcVPrManpWCiJiIioWTQ0NCApKQlvv/02OnXqhOefC0LXghNqfY+3glzQzcJMrcekpuOSNxEREalNY2MjNm/ejJ9++gm//PILysvLbz9mbGyMyspKfJWQjY9+uaTyey0d5YwXRzqqfBxSHa/yJiIiIrXJycnBjBkz7vnYm2++CWNjY8wf6YSObUzx5t5MKJSNTTqn0lBiACOJAd4KckG4Oy/E0RScUBIREZFa/fe//8Urr7xyx+cMDQ2Rl5eHLl263P7cdXkVlu1Ox9HLMhhKDB5YLP9+/BnHjngvxI3L3BqGhZKIiIjU6uLFi3Bzc0N9fT2AP8tkYGAgfvzxx3s+P6ugHNuSchF/qRC5xVX4ZzExwJ+blo/saYWpnrZwtGrb7Pmp6VgoiYiISG0SEhLg4+OD+vp6DBo0CKdPn0ZjYyMOHDiAZ5999qGvr6xVILu4EnUKJUyMJOhuac474GgBFkoiIiJSix07dmDy5MmQSCT4+eefMXToUIwaNQrXr19HVlYWDA0NRUekZsJCSURERCr76KOPsHTpUpiZmSEpKQmurq4AAKVSicrKSrRty6VqXcZCSURERCp56aWX8Omnn8LS0hIZGRl3XHhD+oEnJRAREdFjCwoKwk8//QQHBwekp6fDzIxXX+sjFkoiIiJqMoVCAU9PTyQnJ8PLywsJCQmQSHgDPn2l94WSV5MRERE1TXl5Odzc3JCTk4OwsDB8//33oiORYHrZnG7vd3WxELnye+x3ZWGGkc5WmOJhC6fOPImYiIjob3l5eejTpw9KSkqwZMkSREdHi45EGkCvLsrhjvxERESPLyUlBV5eXqipqcEnn3yCBQsWiI5EGkJvCuV3p3JVumfoyiAXTOQ9Q4mISE8dOHAAY8eORWNjI77//nuMHz9edCTSIHpRKD+Nz8JHv1xS+Tj/GtUT80c6qSERERGR9vj6668xZ84cmJiY4MiRI/Dw8BAdiTSMzl+O9d2pXLWUSQD46JdL2HEqVy3HIiIi0gZvvPEGZs+ejbZt2+LcuXMsk3RPOj2hvC6vgu/qI6hVKB/4vMLvV6D6yunbH9vM+gLGlt3u+VxTIwl+XTyc51QSEZHOmz59OrZs2QIbGxtkZmbiiSeeEB2JNJROTyiX7U6H4iHnS1Zkxt9RJh9GoWzEst3pqkYjIiLSWEqlEiNGjMCWLVvg6uqKa9eusUzSA+lsocwqKMfRy7IHXoDTUHULJb9+DcAAMHy0HZQalI04elmGy4XlakpKRESkOWpqauDi4oIjR45g1KhRSE1NhYmJiehYpOF0tlBuS8qFocTggc8p+e1rKKvL0KbfaBiaWzzysQ0lBtiayHMpiYhIt8hkMnTv3h0XLlxAVFQUDh48yLvf0CPR2b8l8RcLHzidrL6ajMrMwzBsY4EOIyKbdOwGZSPiLxWqGpGIiEhjXLp0Cfb29igoKMBbb72FdevWiY5EWkQn75RTUatArrzqvo8r66pR/PNnAACLUfMgaWXe5PfILa5CZa2Ct2kkIiKtl5CQAB8fH9TX12PTpk2IiIgQHYm0jE5OKHOKK/GgS3FKj2xGQ1khzJ4aCrOeno/1Ho0AsosrH+u1REREmmLHjh0YPnw4lEolDh06xDJJj0UnC2XdA7YJqi++jvIz+yFp1QYWfnOa7X2IiIg0XXR0NCZOnIhWrVrh7Nmz8PHxER2JtJROrteaGN2/JzdUlACNSihrKpAXM+2ez8n/ei6Mrexh83zMY78PERGRJluwYAFiYmJgaWmJ9PR0WFtbi45EWkwnC2V3S3MYAA9c9laVwV/vQ0REpG2Cg4Oxd+9eODg4ID09HWZmvFkHqUYnC6W5qRFsLcyQc48Lc4w62KCDz6y7Pn/r2LdQ1lQAANp5TYBxR9sHvoetpRkvyCEiIq2iUCjg6emJ5ORkeHp64tixY9wWiNRCZxvRSGcrbEnKuWvrIKN2HdHOPfiu55ed2gP8VSjbuHrf99aLwJ/7UI7saaXewERERM2ovLwcbm5uyMnJQVhYGL7//nvRkUiH6OyvJVM8bB+4D6UqGpSNmOr54AkmERGRpsjLy4OdnR1ycnKwZMkSlklSO4PGxsbmPNVQqGnrk3D8arFai2VjgwL1NzIxuPYMnJycYG1tfft/Li4u6NChg9rei4iISFUpKSnw8vJCTU0NPvnkEyxYsEB0JNJBOl0or8ur4Lv6CGrVuL2PQUM98ta+AMWtAhgY/Hlrx7//E7q7u+PkyZNqey8iIiJVHDhwAGPHjkVjYyO+//57jB8/XnQk0lE6u+QNAN0szLAyyEWtx3w3tB+6Wfx5NVxjYyP+2cenTp2q1vciIiJ6XF9//TUCAgJgZGSE48ePs0xSs9LpCeXfPo3Pwke/XFL5OEtHOePFkY44duwYhg4desdj7dq1Q35+PszNuZUQERGJ9cYbb+Cdd95Bu3btcPbsWTg4OIiORDpOpyeUf5s/0gnvj3eDqZEEhhKDJr3WUGIAUyMJPhjvhhdHOgIAhgwZghkzZsDQ0PD288rKytCpUyds3rxZrdmJiIiaIiIiAu+88w5sbGyQnZ3NMkktQi8mlH+7Lq/Cst3pOHpZBkOJwQMv1vn78WccO+K9ELfby9x/KyoqgqOjI8rKyvDyyy/Dzc0Nc+fORXV1Nfr164f9+/fDxsamub8kIiIiAIBSqYSPjw8OHz4MV1dXJCcnw8TERHQs0hN6VSj/llVQjm1JuYi/VIjc4qo77qhjgD83LR/Z0wpTPW3haNX2vsf59ttv8cUXX+DAgQMwNzdHTU0NwsLCsH//fhgaGuLVV1/Fu+++2+xfDxER6beamhr0798fFy5cgJ+fH37++WduWE4tSi8L5T9V1iqQXVyJOoUSJkYSdLc0V/kOOAkJCRg/fjyKiopgY2ODPXv2YNCgQWpKTERE9H9kMhnc3NwglUoRFRWFdevWiY5EekjvC2VzUSqVWLx4MT799FMolUpMmDABW7du5fIDERGpTVZWFgYMGICKigqsXLkSy5cvFx2J9BQLZTO7du0a/P39ceHCBZibm2PTpk0ICwsTHYuIiLRcQkICfHx8UF9fj40bNyIiIkJ0JNJjPMGimdnb2+P8+fP47LPPUF9fjwkTJsDT0xMymUx0NCIi0lI7duzA8OHDoVQqcejQIZZJEo6FsoXMmzcPMpkM3t7eSEpKgrW1NVatWiU6FhERaZno6GhMnDgRrVq1wtmzZ+Hj4yM6EhGXvEU4ePAgJk6ciNLSUtjZ2WH//v1wcVHvHX2IiEj3LFiwADExMbC0tER6ejqsra1FRyICwAmlEKNHj0ZxcTGioqKQm5sLNzc3REZGQqlU3z3HiYhItwQHByMmJgYODg7IyclhmSSNwgmlYOfPn0dgYCCuXr2K9u3b49tvv8WYMWNExyIiIg2hUCjg6emJ5ORkeHp64tixY9xjkjQO/0YK1qtXL1y5cgUffPABKisr4e/vj5EjR6KsrEx0NCIiEqyiogKOjo5ITk5GWFgYTpw4wTJJGol/KzXEK6+8goKCAgwePBiHDx9Gp06dEBMTIzoWEREJkpeXB1tbW+Tk5GDJkiX4/vvvRUciui8ueWug3bt3IyIiAuXl5ejZsyfi4uLQo0cP0bGIiKiFpKSkYPDgwaiursbHH3+MhQsXio5E9ECcUGqgkJAQyOVyTJo0CZcuXYKTkxNefPFFXrRDRKQHDhw4AHd3d9TW1iI2NpZlkrQCJ5QaLiUlBWPHjkVeXh4sLS0RGxuLESNGiI5FRETN4Ouvv8acOXNgYmKCI0eOwMPDQ3QkokfCCaWG69evH65fv44333wTpaWlGDlyJMaMGYOqqirR0YiISI2WL1+O2bNno23btsjMzGSZJK3CCaUWkUqlCAwMRHJyMlq1aoVPP/0UUVFRomMREZGKIiIisHnzZtjY2CAjIwMdOnQQHYmoSVgotdC2bdswe/ZsVFVVwc3NDXFxcejatavoWERE1ERKpRI+Pj44fPgwXF1dkZycDBMTE9GxiJqMS95aaMqUKSguLkZwcDDS09NhZ2eHV199FfzdgIhIe9TU1MDFxQWHDx+Gn58fUlNTWSZJa3FCqeVOnDiBkJAQFBQUoEuXLvjxxx953g0RkYaTyWRwc3ODVCpFVFQU1q1bJzoSkUo4odRyXl5eyM/Px8svv4zCwkJ4enpi/PjxqKurEx2NiIjuISsrC/b29pBKpVi5ciXLJOkETih1SG5uLvz9/ZGZmQkzMzOsX78eEydOFB2LiIj+kpCQAB8fH9TX12Pjxo2IiIgQHYlILTih1CG2trbIyMjAV199hYaGBkyaNAnu7u4oLCwUHY2ISO/t3LkTw4cPh1KpxKFDh1gmSaewUOqg2bNnQy6XY9SoUTh9+jRsbGzw1ltviY5FRKS3oqOjER4eDlNTU5w9exY+Pj6iIxGpFZe8ddzvv/+OCRMmQC6Xo1u3bti3bx/69OkjOhYRkd5YsGABYmJiYGlpibS0NNjY2IiORKR2nFDqOG9vbxQVFeGFF15AXl4e+vXrh6lTp0KhUIiORkSk84KDgxETEwMHBwdkZ2ezTJLO4oRSj2RlZSEgIABZWVlo27Yttm7diqCgINGxiIh0jkKhgKenJ5KTk+Hp6Yljx45BIuEMh3QX/3brEScnJ1y6dAmrV69GTU0NgoOD8cwzz6C0tFR0NCIinVFRUQFHR0ckJycjLCwMJ06cYJkknce/4Xpo0aJFKCwsxLBhw5CQkAArKytER0eLjkVEpPXy8vJga2uLnJwcLFmyBN9//73oSEQtgkveem7fvn2YMmUKysrK0KNHD8TFxaFnz56iYxERaZ2UlBQMHjwY1dXV+Pjjj7Fw4ULRkYhaDCeUei4wMBDFxcWYNm0arl69iqeeegpz5syBUqkUHY2ISGscOHAA7u7uqK2tRWxsLMsk6R1OKOm29PR0BAYGIjc3Fx06dMDOnTvh6+srOhYRkUZbt24dZs+eDRMTExw5cgQeHh6iIxG1OE4o6TY3Nzfk5OTg7bffRnl5Ofz8/ODn54eKigrR0YiINNLy5csxa9YstG3bFpmZmSyTpLc4oaR7KioqQmBgIE6ePAlTU1N8/PHHeOGFF0THIiLSGBEREdi8eTOsra2RkZEBCwsL0ZGIhGGhpAfasWMHoqKiUFlZid69eyMuLg52dnaiYxERCaNUKuHj44PDhw/D1dUVycnJMDExER2LSCguedMDhYeHQy6XIzQ0FOfOnYODgwOWLFnCi3aISC/V1NTAxcUFhw8fhq+vL1JTU1kmicAJJTXBqVOnEBwcjJs3b8LKygo//PADhgwZIjoWEVGLkMlkcHNzg1QqRVRUFNatWyc6EpHG4ISSHpm7uzvy8/Px2muvQSaTYejQoQgODkZNTY3oaEREzSorKwv29vaQSqVYuXIlyyTR/+CEkh5LXl4eAgICkJaWhtatW2Pt2rWYOnWq6FhERGqXkJAAHx8f1NfXY+PGjYiIiBAdiUjjcEJJj6Vr165ITU3Fhg0b0NjYiGnTpmHAgAGQSqWioxERqc3OnTsxfPhwKJVKHDp0iGWS6D5YKEklkZGRKC4uhr+/P86ePYuuXbti+fLlomMREaksOjoa4eHhMDU1xdmzZ+Hj4yM6EpHG4pI3qc0ff/yB0NBQyGQyPPnkk9i7dy8GDBggOhYRUZMtWLAAMTExsLS0RFpaGmxsbERHItJonFCS2gwbNgwFBQV46aWXkJ+fj4EDB2LixIlQKBSioxERPbJx48YhJiYGDg4OyM7OZpkkegScUFKzuHr1Kvz9/XHx4kW0adMG33zzDcaPHy86FhHRfSkUCnh6eiI5ORkeHh44fvw4JBLOXYgeBf+lULNwcHDAhQsXEBMTg7q6OoSGhmLw4MGQy+WioxER3aWiogKOjo5ITk5GaGgoEhMTWSaJmoD/WqhZzZ8/H0VFRRg5ciROnDiBzp0744MPPhAdi4jotry8PNja2iInJwdLlixBbGys6EhEWodL3tRiDhw4gMmTJ6O0tBTdu3fH/v370bt3b9GxiEiPpaSkYPDgwaiursbHH3+MhQsXio5EpJU4oaQWM2bMGBQXFyMyMhI5OTlwdXXF888/z/uCE5EQBw4cgLu7O2praxEbG8sySaQCTihJiPPnzyMgIADXrl3DE088ge3bt2PMmDGiYxGRnli3bh1mz54NExMTHDlyBB4eHqIjEWk1TihJiF69euHq1atYtWoVKioq4O/vD29vb5SVlYmORkQ6bvny5Zg1axbatm2LzMxMlkkiNeCEkoSTy+UIDAzEiRMnYGJigujoaMyfP190LCLSQREREdi8eTOsra2RkZEBCwsL0ZGIdAILJWmMXbt2YcaMGaioqICzszMOHDgAe3t70bGISAcolUr4+voiPj4erq6uSE5OhomJiehYRDqDS96kMUJDQ1FSUoKJEyfi4sWLcHR0xEsvvcSLdohIJTU1NXBxcUF8fDx8fX2RmprKMkmkZpxQkkY6c+YMgoKCcOPGDXTs2BG7du3CsGHDRMciIi0jk8ng5uYGqVSK559/HuvXrxcdiUgncUJJGmnAgAHIy8vDG2+8gZKSEgwfPhwBAQGoqqoSHY2ItERWVhbs7e0hlUqxcuVKlkmiZsQJJWk8qVSKgIAAnDlzBq1atcLnn3+OyMhI0bGISIMdO3YM3t7eqK+vx4YNGzBjxgzRkYh0GieUpPG6dOmC5ORkbNmyBQYGBnj++efRt29f5OXliY5GRBpo586dGDZsGJRKJQ4ePMgySdQCWChJa0ydOhVyuRxBQUFIS0uDnZ0dXnvtNdGxiEiDREdHIzw8HKampjh79iz8/PxERyLSC1zyJq107NgxjB8/HoWFhejSpQv27t0Ld3d30bGISKAFCxYgJiYGlpaWSEtLg42NjehIRHqDE0rSSkOGDMHNmzexePFiFBYW4umnn0ZYWBjq6upERyMiAcaNG4eYmBg4ODggOzubZZKohXFCSVovJycH/v7+OHfuHMzNzbF+/XqEh4eLjkVELUChUMDT0xPJycnw8PDA8ePHIZFwVkLU0vivjrSenZ0dMjMz8eWXX0KhUGDixIl4+umnUVhYKDoaETWjiooKODo6Ijk5GaGhoUhMTGSZJBKE//JIZ8yZMwcymQx+fn44deoUnnzySbzzzjuiYxFRM8jLy4OdnR1ycnKwePFixMbGio5EpNe45E066bfffsOECRNQUlICW1tb7N+/H66urqJjEZEapKamwsvLC9XV1Vi9ejUWLVokOhKR3uOEknSSj48PZDIZ5syZg+vXr6NPnz6YPn06FAqF6GhEpIIDBw5g0KBBqK2tRWxsLMskkYbghJJ03sWLFxEYGIjLly+jXbt22LZtGwIDA0XHIqImWrduHWbPng0TExMcPnwYnp6eoiMR0V84oSSd5+zsjKysLERHR6O6uhpjx47FsGHDUFpaKjoaET2i5cuXY9asWWjbti0yMzNZJok0DCeUpFdKS0sRFBSEo0ePwtjYGB988AEWL14sOhYRPUBERAQ2b94Ma2trZGRkwMLCQnQkIvofLJSkl/bu3Ytp06ahrKwMjo6OiIuLg5OTk+hYRPQPSqUSvr6+iI+Ph6urK5KTk2FiYiI6FhHdA5e8SS8FBQWhuLgYU6dOxeXLl+Hs7IwXXngBSqVSdDQiAlBTUwMXFxfEx8fD19cXqampLJNEGowTStJ7aWlpCAwMxPXr12FhYYGdO3fCx8dHdCwivSWTyeDm5gapVIrIyEhs2LBBdCQieghOKEnv9enTB7m5uVi5ciVu3boFX19fjB49GpWVlaKjEemdrKws2NvbQyqVYuXKlSyTRFqCE0qifygsLERAQABOnz4NU1NTrFmzBrNnzxYdi0gvJCQkwMfHB/X19diwYQNmzJghOhIRPSJOKIn+wcrKCqdOncJ3330HQ0NDzJkzBy4uLsjJyREdjUin7dy5E8OHD4dSqcQvv/zCMkmkZVgoie4hPDwcJSUlGD9+PM6dOwcHBwe8/PLLvGiHqBlER0cjPDwcpqamOHv2LHx9fUVHIqIm4pI30UMkJSVh3LhxkEqlsLKywo8//ggvLy/RsYh0woIFCxATEwNLS0ukpaXBxsZGdCQiegycUBI9hIeHB27evIlXXnkFMpkMgwcPxrhx41BbWys6GpFWGzduHGJiYuDg4IDs7GyWSSItxgklURPk5eXB398f6enpMDMzw9q1azFlyhTRsYi0ikKhgKenJ5KTk+Hh4YHjx49DIuF8g0ib8V8wURN07doVaWlpWLduHZRKJaZOnYqBAwdCKpWKjkakFSoqKuDo6Ijk5GSEhoYiMTGRZZJIB/BfMdFjiIqKQnFxMcaMGYMzZ86ga9euePPNN0XHItJoeXl5sLOzQ05ODhYvXozY2FjRkYhITbjkTaSiw4cPIywsDMXFxejatSt++ukn9OvXT3QsIo2SmpoKLy8vVFdXY/Xq1Vi0aJHoSESkRpxQEqloxIgRKCwsxIsvvogbN26gf//+mDRpEhQKhehoRBrh559/xqBBg1BbW4vY2FiWSSIdxAklkRpduXIF/v7+uHTpEtq2bYtvvvkGISEhomMRCbNu3TrMnj0bxsbGOHLkCDw9PUVHIqJmwAklkRr16NEDFy9exJo1a1BbW4vx48djyJAhkMvloqMRtbjly5dj1qxZaNu2Lc6dO8cySaTDOKEkaiZlZWUIDg7G4cOHYWxsjHfeeQevvPKK6FhELSIiIgKbN2+GtbU1MjIyYGFhIToSETUjFkqiZhYXF4fJkyfj1q1bsLe3x/79+9GrVy/RsYiahVKphK+vL+Lj4+Hq6ork5GSYmJiIjkVEzYxL3kTNzN/fH3K5HDNmzEB2djZcXFwwc+ZM3hecdE5NTQ1cXFwQHx8PX19fpKamskwS6QlOKIlaUGZmJgIDA5GdnY0nnngC3333HUaPHi06FpHKZDIZ3NzcIJVKERkZiQ0bNoiOREQtiBNKohbk4uKCa9eu4b333kNFRQWeffZZ+Pj4oKKiQnQ0oseWlZUFe3t7SKVSrFixgmWSSA9xQkkkiEwmw9ixY5GYmAgTExOsXr0a8+bNEx2LqEkSEhLg4+OD+vp6rF+/HpGRkaIjEZEALJREgu3atQszZsxARUUFnnrqKcTFxcHe3l50LKKH2rlzJyZNmgSJRIK4uDj4+fmJjkREgnDJm0iw0NBQFBcXIzw8HBcuXICjoyMWLlzIi3ZIo0VHRyM8PBympqY4e/YsyySRnuOEkkiDJCcnIygoCPn5+ejYsSN++OEHPPPMM6JjEd1hwYIFiImJgaWlJdLS0mBjYyM6EhEJxgklkQYZOHAgbty4gX//+98oKSnBsGHDEBgYiJqaGtHRiAAA48aNQ0xMDBwcHJCdnc0ySUQAOKEk0lj5+fkICAhASkoKWrVqhS+//BIRERGiY5GeUigU8PT0RHJyMjw8PHD8+HFIJJxJENGf+N2ASEPZ2Njg7Nmz+Oabb2BgYIAZM2agX79+yM/PFx2N9ExFRQUcHR2RnJyM0NBQJCYmskwS0R34HYFIw02fPh1yuRyBgYFITU2Fra0tXn/9ddGxSE/k5eXBzs4OOTk5WLx4MWJjY0VHIiINxCVvIi2SkJCA8ePHo6ioCNbW1tizZw/c3d1FxyIdlZaWBk9PT1RXV2P16tVYtGiR6EhEpKE4oSTSIkOHDoVUKsWiRYtQUFCAp59+GhMmTEBdXZ3oaKRjfv75ZwwcOBC1tbWIjY1lmSSiB+KEkkhL5eTkYMyYMTh//jzMzc2xadMmhIWFiY5FOmD9+vWYNWsWjI2NcfjwYXh5eYmOREQajhNKIi1lZ2eHc+fO4fPPP4dCocCECRPg6ekJmUwmOhppseXLl2PmzJlo27Ytzp07xzJJRI+EE0oiHVBRUYGQkBD8+uuvMDIywsqVK7Fs2TLRsUjLREREYPPmzbC2tkZGRgYsLCxERyIiLcFCSaRDDh06hPDwcJSUlMDOzg779u2Dq6ur6Fik4ZRKJXx9fREfHw9XV1ckJyfDxMREdCwi0iJc8ibSIX5+fpDJZJg1axZyc3PRp08fREREoKGhQXQ00lA1NTVwcXFBfHw8fH19kZqayjJJRE3GCSWRjrp48SICAgJw5coVtGvXDtu3b0dAQIDoWKRBZDIZ3NzcIJVKERkZiQ0bNoiORERaihNKIh3l7OyMy5cv47///S+qq6sRGBiI4cOH49atW6KjkQbIysqCvb09pFIpVqxYwTJJRCrhhJJID5SUlGDs2LE4duwYjI2N8eGHH3JfQT127NgxeHt7o76+HuvXr0dkZKToSESk5VgoifTInj17MG3aNJSXl8PJyQlxcXFwdHQUHYta0M6dOzFp0iRIJBLExcXBz89PdCQi0gFc8ibSI8HBwZDL5Zg8eTKysrLQs2dPzJ07F0qlUnQ0agHR0dEIDw+Hqakpzp49yzJJRGrDCSWRnkpJSUFQUBCuX78OS0tL7Ny5E97e3qJjUTNZuHAh1qxZA0tLS6SlpcHGxkZ0JCLSIZxQEumpfv36ITc3FytWrEBpaSl8fHzw7LPPoqqqSnQ0UrNx48ZhzZo1sLe3R3Z2NsskEakdJ5REhMLCQvj7+yM5ORmtWrVCTEwMZs6cKToWqUihUMDT0xPJycnw8PDA8ePHIZFwjkBE6sfvLEQEKysrnD59Gtu3b4dEIsGsWbPg5uaG3Nxc0dHoMVVUVMDR0RHJyckIDQ1FYmIiyyQRNRt+dyGi2yZNmoSSkhKEhIQgIyMD9vb2WLp0KS/a0TJ5eXmws7NDTk4OFi9ejNjYWNGRiEjHccmbiO4pKSkJ48aNg1QqRefOnbFnzx54eHiIjkUPkZaWBk9PT1RXV2P16tXcb5SIWgQnlER0Tx4eHrhx4waWLl2KoqIieHp6IiQkBHV1daKj0X0cPHgQAwcORG1tLWJjY1kmiajFcEJJRA+Vm5uLgIAAZGRkwMzMDOvWrcOkSZNEx6J/WL9+PWbNmgVjY2McPnwYXl5eoiMRkR7hhJKIHsrW1hbp6elYu3YtGhoaMHnyZAwaNAgFBQWioxGA5cuXY+bMmWjTpg3OnTvHMklELY4TSiJqkqqqKoSGhuLnn3+GoaEh/vOf/2DFihWiY+mtiIgIbN68GdbW1sjIyICFhYXoSESkh1goieix/P7775gwYQLkcjm6du2Kffv2oW/fvqJj6Q2lUglfX1/Ex8fDxcUFZ86cgYmJiehYRKSnuORNRI/F29sbRUVFmDt3Lm7cuIF+/fphypQpUCgUoqPpvJqaGri4uCA+Ph6+vr5IS0tjmSQioTihJCKVZWVlISAgAFlZWWjbti22bNmC4OBg0bF0kkwmg5ubG6RSKSIjI7FhwwbRkYiIOKEkItU5OTnh0qVL+Pjjj1FbW4tx48Zh6NChKC0tFR1Np2RlZcHe3h5SqRQrVqxgmSQijcEJJRGpVVlZGYKCgnDkyBEYGxtj1apVePnll0XH0nrHjh2Dt7c36uvrsX79ekRGRoqORER0GwslETWLuLg4TJ48Gbdu3YKDgwPi4uLg7OwsOpZW2rlzJyZNmgSJRIK4uDj4+fmJjkREdAcueRNRs/D394dMJkNERASuXbuGXr16Yfbs2bwveBNFR0cjPDwcpqamOHv2LMskEWkkTiiJqNllZGQgMDAQOTk56NChA3bs2MFi9AgWLlyINWvWwMLCAunp6bCxsREdiYjonjihJKJm5+rqiuzsbLzzzjsoLy/HqFGj4Ovri4qKCtHRNNa4ceOwZs0a2NvbIycnh2WSiDQaJ5RE1KJkMhkCAwORlJQEU1NTrF69GnPnzhUdS2MoFAp4enoiOTkZHh4eOHbsGAwNDUXHIiJ6IE4oiahFdezYEYmJidixYweMjIwwb9489O7dGzk5OaKjCVdRUQFHR0ckJycjNDQUiYmJLJNEpBVYKIlIiOeeew5yuRxhYWE4f/48HBwcsGjRIr29aCcvLw92dnbIycnB4sWLERsbKzoSEdEj45I3EQl36tQpBAcH4+bNm+jUqRN++OEHDB06VHSsFpOWlgZPT09UV1dj9erVWLRokehIRERNwgklEQnn7u6O/Px8vP766yguLsYzzzyDsWPHoqamRnS0Znfw4EEMHDgQtbW1iI2NZZkkIq3ECSURaZT8/Hz4+/sjNTUVrVu3xpdffonp06eLjtUs1q9fj1mzZsHY2BiHDx+Gl5eX6EhERI+FE0oi0ig2NjZISUnBpk2b0NjYiIiICPTv3x/5+fmio6nV8uXLMXPmTLRp0wbnzp1jmSQircYJJRFprJqaGoSFhWH//v0wNDTEq6++infffVd0LJVFRERg8+bNsLa2RkZGBiwsLERHIiJSCQslEWm8hIQEjB8/HkVFRbCxscGePXswaNAg0bGaTKlUwtfXF/Hx8XBxccGZM2dgYmIiOhYRkcq45E1EGm/o0KGQSqVYsGABpFIp3N3d8dxzz6Gurk50tEdWU1MDFxcXxMfHw9fXF2lpaSyTRKQzOKEkIq1y7do1+Pv748KFC2jTpg02bdqE0NBQ0bEeSCaTwc3NDVKpFJGRkdiwYYPoSEREasUJJRFpFXt7e5w/fx6fffYZ6urqEBYWBi8vLxQXF4uOBgAoLCzE5s2b8ffv6llZWbC3t4dUKsWKFStYJolIJ7FQEpFWmjdvHoqKiuDt7Y3ExER06dIFq1atEh0Lb7zxBiIiIvDGG2/g2LFjcHV1RWVlJTZs2IA333xTdDwiombBJW8i0noHDx7ExIkTUVpaiu7du2Pfvn1wcXG5/Xh9fT1KS0vRqVOnZs1RUVGBzp07o6qqCgBgYGAAQ0NDxMXFwc/Pr1nfm4hIJE4oiUjrjR49GsXFxYiKikJOTg7c3NwQGRl5+77gYWFhcHZ2bvKyeGWtApn5t3A2twSZ+bdQWat44PN37Nhxu0wCQGNjIz766COWSSLSeZxQEpFOOX/+PAIDA3H16lW0b98eL730Et555x0YGBggKioKX3/99QNfn1VQjm1JuYi/WIhceRX++Q3SAICthRlGOlthioctnDq3veO1gwYNQnJy8h2fMzEx4V1wiEjnsVASkU768MMPsWzZMjQ0NNzx+RMnTsDT0/Ou51+XV2HZ7nQcvSyDocQADcr7f2v8+/FnHDvivRA3dLMwQ1paGvr27Xv7ORLJnwtASqUSy5cvx8qVK9X0lRERaR4WSiLSWbNmzcK6detufyyRSG5vKG5kZHT789+dysWbezOhUDY+sEj+L0OJAYwkBlgR2BuvTngG169fBwCYmppixIgRePbZZzFq1Cj06tULBgYG6vvCiIg0DAslEemk5ORkuLu7417f4v45Mfw0Pgsf/XJJ5fcrObIZtuXnsGbNGgwePBimpqYqH5OISFsYPfwpRETap6ysDJ07d0ZhYeHti3P+9tZbb8HJyQmGPYeppUwCQIfh0/Gf8W4Y6W6rluMREWkTTiiJSKcplUrIZDLcvHkTN2/eRFJSErZv346rBbfQ/cX1qFfe+3WNinqUndyNysx41JdKITFuBdNuLmg/ZCJMuzje8zWmRhL8ung4ulmYNeNXRESkeVgoiUgvhaz5HWkFNfc8Z7JR2YDCHctRk5N69wsNjWE14U207t7v7ockBhjsYIktUR7NkJiISHNxH0oi0jtZBeU4e7P6vhfglJ/Zf7tMGneyQ6eQZWg/OPzPBxvqUbz/YzQq6u96XYOyEUcvy3C5sLzZshMRaSIWSiLSO9uScmEouf9V1xVnD9z+s+WzL8HMeTCeGDYNrewHAAAaymWounzynq81lBhga2KuegMTEWk4Fkoi0jvxFwvvO51sqC5HffGf2/9AYgQTa6fbj5k+2ev2n2vzMu/9emUj4i8Vqi8sEZEWYKEkIr1SUatArrzqvo8rbhXc/rNh67YwkBj+38fm7f/veaUFuJ/c4qqH3qaRiEiXsFASkV7JKa7Eg65EbKyv+b8PDO/cWc1AYnTv5/3vMQBkF1c+ZkIiIu3DQklEeqVOcZ99gv5iYNzq9p8bG+688KZRqbjn8x7nfYiIdAkLJRHpFROjB3/bM2rf+fafldXlaFT+373AGypK/u95T3TGgzzsfYiIdAm/4xGRXuluaY4H3VXbsHVbGFt2+/MDZQPqbv7fnXRq8y/c/rNpV5f7HsPgr/chItIXLJREpFfMTY1g+5A72bTpP+b2n4sPxKDq4nGU/LEFNdfOAgAM23aEmePT9329raUZzE15Z1si0h8slESkd0Y6Wz1wH8q2AwLQyq4vAKBeloui3e+h7PiOPx80NIZlwCIYGBnf87WGEgOM7Gml9sxERJqMt14kIr2TVVAOv4//eOBz/r6Xd0Xm71CUFvx5L++uvdF+6KT73sv7b78uHgZHq7bqjExEpNFYKIlIL01bn4TjV4vvu8H542hsUMBIfg0vDzCBk5MTrK2tYW1tDQsLCxgYPOjMTSIi7cZCSUR6KUdWAe/oeDSo8cwfiVKB61/NuWNzdAAwNjZG9+7d8ccff6BLly5qez8iIk3BcyiJSK/I5XJ88803GNTLHoVxn6r12KvC+sPD9e7l8Pr6epSWlqJNmzZqfT8iIk3ByxCJSKfV1dUhMTERhw4dQlxcHM6ePYu/F2YiAqwxaFRPfPTLpYcc5eGWjnJGuLsthnz3HZycnFBTc+eddD799FMWSiLSWVzyJiKdNnToUBw7dgyGhoZoaPi/TcrNzc1RUlICY2NjfHcqF2/uzYRC2dikcyoNJQYwkhjgrSAXhLvb3v58dHQ0li5din9+e23fvj2+/fZbjBkz5l6HIiLSalzyJiKd9txzzwHAHWVSIpHgpZdegrHxn1v/THS3xa+Lh2OwgyUAPHBLoX8+PtjBEr8uHn5HmQSABQsWoGfPngCAVq1a4dVXX0VlZSX8/f3h7e2NsrIy9XxxREQaghNKItJ5fn5++PXXX+/43OXLl9GjR4+7nptVUI5tSbmIv1SI3OIq/PMbpAH+3LR8ZE8rTPW0feDWQEePHsXw4cMRHR2NxYsXQy6XY+zYsTh+/DhMTEwQHR2N+fPnq+krJCISi4WSiHTasmXLsGrVKhgZGd2eUg4fPhzx8fEPfW1lrQLZxZWoUyhhYiRBd0vzJt0BRyqVonPnzndsGbR7925Mnz4dFRUV6NmzJ+Li4u5ZbImItAmXvIlIZ02ZMgWrVq3Ck08+iRs3bmD48OFobGzE3LlzH+n15qZGcLFpj/62HeBi077Jt1Ps0qXLXftPhoSEoKSkBJMmTcKlS5fg5OSEF198EUqlsknHJiLSJJxQEpHOUSqVGD58OBISEtCnTx+cOnUKJiYmKCsrw65duzBt2jQYGYnf5CIlJQVjx45FXl4eLC0tERsbixEjRoiORUTUZCyURKRTqqur0bdvX2RlZWHMmDHYt28fJBLNXoxZsWIF3nnnHTQ0NODZZ5/Frl27YGZmJjoWEdEjY6EkIp1RWFgIV1dXFBUVYc6cOfjyyy9FR3pkUqkUgYGBSE5ORqtWrRATE4OZM2eKjkVE9Eg0+9d2IqJHdP78eTg4OKCoqAjvvfeeVpVJ4M/zLU+fPo3t27dDIpFg1qxZcHNzQ25uruhoREQPxUJJRFrv8OHD6Nu3L6qqqrB161a8/vrroiM9tkmTJqGkpAQhISHIyMiAvb09li5dyot2iEijccmbiLTa1q1bMX36dBgZGeGXX37RqYtakpKSMG7cuNvbD+3evRteXl6iYxER3YUTSiLSWqtWrcK0adNgZmaG1NRUnSqTAODh4YEbN25g6dKlKCoqwuDBgxESEoK6ujrR0YiI7sAJJRFppRdeeAFfffUVOnXqhIyMDFhZWYmO1Kxyc3MRGBiI9PR0mJmZYe3atZgyZYroWEREAFgoiUjLKJVKBAQE4Oeff4aTkxPS0tLQqlUr0bFazPr16zF//nzU1NRgwIAB2L9/P7p06SI6FhHpOS55E5HWqKurQ//+/fHzzz/jmWeewYULF/SqTAJAVFQUiouLMWbMGJw5cwZdu3bF8uXLRcciIj3HCSURaYXS0lK4urrixo0bmDx5MrZt2yY6knB//PEHxo8fj+LiYjz55JPYu3cvBgwYIDoWEekhTiiJSONdu3YN3bt3x40bN/D666+zTP5l2LBhKCwsxPz585Gfn4+BAwdi0qRJUCgUoqMRkZ7hhJKINNrJkycxbNgw1NXV4YsvvsCcOXNER9JIV65cQWBgIC5cuIA2bdpg06ZNCA0NFR2LiPQEJ5REpLF2796NwYMHQ6FQYN++fSyTD9CjRw+cP38eMTExqKurQ1hYGLy8vCCXy0VHIyI9wEJJRBopJiYGoaGhMDY2xsmTJ+Hv7y86klaYP38+ioqK4O3tjcTERHTu3Bnvv/++6FhEpOO45E1EGudf//oXoqOj8cQTTyA1NRW2traiI2mlgwcPYuLEiSgtLYWdnR32798PFxcX0bGISAdxQklEGmXChAmIjo6Gra0tcnJyWCZVMHr0aBQXFyMqKgq5ublwc3NDZGQk7wtORGrHCSURaQSlUokhQ4YgMTERAwcORGJiIoyMjETH0hnnz59HYGAgrl69ivbt22P79u08jYCI1IYTSiISrqqqCk5OTkhMTERQUBBOnz7NMqlmvXr1wpUrV/Dhhx+iqqoKAQEBGDFiBMrKykRHIyIdwEJJRELl5+fD1tYWV69exUsvvYQ9e/aIjqTTli5dCqlUiiFDhuDIkSPo1KkTPvnkE9GxiEjLccmbiITJyMiAh4cHqqqq8NFHH+Hll18WHUmv7NmzB9OmTUN5eTmcnJywf/9+ODk5iY5FRFqIE0oiEuLQoUPo378/ampqsGPHDpZJAYKDgyGXyzF58mRkZWXB2dkZc+fO5UU7RNRknFASUYvbuHEjoqKiYGxsjN9//x1DhgwRHUnvpaWlITAwENevX4eFhQW+//57eHt7i45FRFqCE0oialErV67E888/D3Nzc2RkZLBMaog+ffogNzcXK1euxK1bt+Dj44PRo0ejqqpKdDQi0gKcUBJRi3n++eexceNGdOnSBenp6ejYsaPoSHQPhYWFCAwMxKlTp2Bqaoo1a9Zg9uzZomMRkQZjoSSiZqdUKjFq1Cj89ttv6NWrF86cOYNWrVqJjkUPsWPHDkRFRaGyshK9e/dGXFwc7OzsRMciIg3EJW8ialZ1dXVwc3PDb7/9Bm9vb2RkZLBMaonw8HDI5XKEhobi3LlzcHBwwJIlS3jRDhHdhRNKImo2crkcLi4ukEqliIiIwKZNm0RHosd06tQpBAcH4+bNm7CyssIPP/zA81+J6DZOKImoWVy+fBndu3eHVCrFm2++yTKp5dzd3ZGfn4/XXnsNMpkMQ4cORXBwMGpqakRHIyINwAklEandsWPH4O3tjfr6eqxfvx6RkZGiI5Ea5eXlITAwEKmpqWjdujXWrl2LqVOnio5FRAJxQklEarVz504MGzYMSqUSBw4cYJnUQV27dkVKSgo2bdqExsZGTJs2Df3790d+fr7oaEQkCAslEalNdHQ0wsPDYWpqiuTkZIwePVp0JGpGERERKCkpQUBAAFJSUmBra4t///vfomMRkQBc8iYitVi4cCHWrFkDCwsLpKenw8bGRnQkakEJCQkYP348ioqKYGNjgz179mDQoEGiYxFRC+GEkohUNm7cOKxZswb29vbIyclhmdRDQ4cOhVQqxYIFCyCVSuHu7o7nnnsOdXV1oqMRUQvghJKIHptCoYCnpyeSk5Ph4eGB48ePQyLh76n67tq1awgICMD58+dhbm6OTZs2ISwsTHQsImpG/M5PRI+lvLwcjo6OSE5ORmhoKBITE1kmCQBgb2+Pc+fO4fPPP4dCocCECRPg4eEBmUwmOhoRNRN+9yeiJsvLy4OdnR1ycnKwZMkSxMbGio5EGmju3LmQyWTw9fXFyZMnYW1tjXfffVd0LCJqBlzyJqImOXv2LAYPHoyamhp8/PHHWLhwoehIpAUOHTqE8PBwlJSUwM7ODvv27YOrq6voWESkJpxQEtEjO3DgANzd3VFXV4cffviBZZIemZ+fH2QyGWbNmoXc3Fz06dMHERERUCgUoqMRkRpwQklEj2Tt2rV44YUXYGJigiNHjsDDw0N0JNJSFy9eREBAAK5cuYJ27dph27ZtCAwMFB2LiFTACSURPdS///1vzJkzB23btsX58+dZJkklzs7OuHz5MqKjo1FdXY2xY8di2LBhKC0tFR2NiB4TJ5RE9EBTp07Ftm3b8OSTTyIjIwNPPPGE6EikQ0pLSxEUFISjR4/C2NgY77//PpYsWSI6FhE1EQslEd2TUqnEyJEj8ccff8DNzQ2nT5+GiYmJ6Fiko/bu3Ytp06ahrKwMjo6OiIuLg5OTk+hYRPSIuORNRHepqalBr1698Mcff2D06NFISUlhmaRmFRQUhOLiYkybNg1XrlyBs7MzXnjhBSiVStHRiOgRcEJJRHcoLCyEm5sbCgsLMWvWLKxdu1Z0JNIz6enpCAwMRG5uLjp06ICdO3fC19dXdCwiegBOKInotvPnz8PBwQGFhYV45513WCZJCDc3N+Tk5ODtt99GeXk5/Pz84Ofnh4qKCtHRiOg+OKEkIgDAkSNH4OfnB4VCgU2bNmH69OmiIxFBJpMhICAAJ0+ehKmpKVavXo25c+eKjkVE/4MTSiLC9u3b4e3tDQD49ddfWSZJY3Ts2BFJSUnYsWMHjIyMMG/ePPTu3Rs5OTmioxHRP7BQEum5999/H1OmTEHr1q1x9uzZ28WSSJM899xzkMvlCAsLu31qxsKFC3nRDpGG4JI3kR6bO3cuvvzyS3Tq1AlpaWno0qWL6EhED3X69GkEBwcjPz8fnTp1wg8//IChQ4eKjkWk1zihJNJDSqUS/v7++PLLL+Hk5ITs7GyWSdIagwYNwo0bN7Bs2TLI5XI888wzCAwMRE1NjehoRHqLE0oiPVNfXw93d3ekpqZiyJAh+OOPPyCR8HdL0k75+fkICAhASkoKWrdujS+++AIRERGiYxHpHf4UIdIjpaWlcHBwQGpqKiZOnIiEhASWSdJqNjY2OHv2LL755hsAwIwZM9CvXz/k5+cLTkakX/iThEhP5OTkoHv37sjLy8Nrr72Gb7/9VnQkIrWZPn065HI5goKCkJqaim7duuH1118XHYtIb3DJm0gPnDp1Cs888wzq6urw2WefcR8/0mkJCQkYP348ioqKYG1tjT179sDd3V10LCKdxgklkY7bs2cPvLy8oFAosHfvXpZJ0nlDhw6FVCrF4sWLUVBQgKeffhphYWGoq6sTHY1IZ3FCSaTDPvvsM7z00kswNTXF0aNHMWjQINGRiFpUTk4O/P39ce7cOZibm2P9+vUIDw8XHYtI53BCSaSjXnnlFcyfPx/t27fHxYsXWSZJL9nZ2SEzMxNfffUVFAoFJk6ciKeffhqFhYWioxHpFE4oiXTQc889h++//x7dunVDRkYG2rVrJzoSkXAVFRUIDQ3FL7/8AiMjI7zxxhtYvny56FhEOoGFkkiHKJVKDB06FCdOnED//v1x8uRJGBkZiY5FpFF+++2327dy7NatG/bt24c+ffqIjkWk1bjkTaQjqqqq0LNnT5w4cQKBgYE4c+YMyyTRPfj4+KCoqAgvvPAC8vLy0K9fP0ydOhUKhUJ0NCKtxQklkQ6QSqVwc3ODTCbDvHnz8Nlnn4mORKQVsrKyEBAQgKysLLRt2xZbt25FUFCQ6FhEWocTSiItl5GRgR49ekAmk+HDDz9kmSRqAicnJ1y6dAmrV69GTU0NgoODMXToUJSWloqORqRVOKEk0mK//fYbnn32WSiVSmzfvp3boRCpoKysDEFBQThy5AiMjY2xatUqvPzyy6JjEWkFFkoiLfXNN98gMjISxsbG+O233zB06FDRkYh0QlxcHCZPnoxbt27BwcEBcXFxcHZ2Fh2LSKNxyZtIC7311luYMWMGzM3NkZaWxjJJpEb+/v6QyWSIiIjAtWvX0KtXL8yaNQtKpVJ0NCKNxQklkZaZOXMm1q9fj86dOyMjIwMdO3YUHYlIZ2VmZiIwMBDZ2dl44oknsGPHDowaNUp0LCKNwwklkZZQKpXw8/PD+vXr8dRTTyE7O5tlkqiZubi44Nq1a3jvvfdQUVGB0aNHw8fHBxUVFaKjEWkUTiiJtEBdXR0GDBiAzMxMjBw5Er/++iskEv4+SNSSZDIZxo4di8TERJiYmGD16tWYN2+e6FhEGoE/kYg0nFwuR/fu3ZGZmYnp06fj999/Z5kkEqBjx444ceIEYmNjYWJighdffBG9evXCtWvXREcjEo4/lYg02JUrV9C9e3fcvHkTb7zxBr755hvRkYj0XmhoKORyOcLDw3HhwgU4OjpiwYIFvGiH9BqXvIk01IkTJzBixAjU19dj7dq1mDlzpuhIRPQ/zpw5g6CgINy4cQMdO3bErl27MGzYMNGxiFocJ5REGmjXrl0YOnQolEol9u/fzzJJpKEGDBiAvLw8vPHGGygpKcHw4cPh7++Pqqoq0dGIWhQnlEQa5uOPP8bixYvRunVrnDhxAn379hUdiYgegVQqRUBAAM6cOYNWrVrh888/R2RkpOhYRC2ChZJIgyxatAiffPIJLCwskJqaiq5du4qORERNtHXrVsyePRvV1dVwc3NDXFwc/y2TzmOhJNIQISEh+PHHH9G9e3ekp6ejTZs2oiMR0WOqqanBxIkTsWfPHkgkEvzrX//CBx98IDoWUbNhoSQSTKFQwMvLC6dPn8bTTz+NY8eOwcjISHQsIlKDEydOICQkBAUFBejSpQt+/PFHeHh4iI5FpHa8KIdIoIqKCjg5OeH06dMICQlBUlISyySRDvHy8kJ+fj7+9a9/obCwEJ6enhg/fjzq6upERyNSK04oiQTJy8tD3759IZfLsWjRIqxevVp0JCJqRrm5uQgICEBGRgbMzMywbt06TJo0SXQsIrXghJJIgNTUVPTs2RNyuRyrV69mmSTSA7a2tkhPT8dXX32FhoYGTJ48GYMGDUJhYaHoaEQqY6EkamEHDhzAoEGDUFtbi9jYWCxatEh0JCJqQbNnz4ZcLsezzz6L5ORk2NjYYMWKFaJjEamES95ELWjdunWYPXs2jI2NcfjwYXh5eYmOREQCxcfHY8KECSguLkbXrl3x008/oV+/fqJjETUZJ5RELeSNN97ArFmz0LZtW5w7d45lkogwcuRIFBYWYt68ebhx4wb69++PyZMnQ6FQiI5G1CScUBK1gOnTp2PLli2wsbFBeno6LCwsREciIg1z5coV+Pv749KlS2jbti2++eYbhISEiI5F9Eg4oSRqRkqlEiNGjMCWLVvg6uqKa9eusUwS0T316NEDFy9exJo1a1BbW4vx48djyJAhkMvloqMRPRQLJVEzqampQe/evXHkyBH4+fkhNTUVJiYmomMRkYZ76aWXUFRUhBEjRuD48ePo0qULPvzwQ9GxiB6IS95EzUAmk8HV1RUFBQWIiorCunXrREciIi104MABTJo0Cbdu3YK9vT3279+PXr16iY5FdBdOKInU7OLFi7C3t0dBQQHefvttlkkiemxjxoyBXC5HZGQksrOz4eLigueffx5KpVJ0NKI7cEJJpEZHjx6Fj48PFAoFNm7ciIiICNGRiEhHnD9/HgEBAbh27RqeeOIJbN++HWPGjBEdiwgAJ5REavPtt99ixIgRaGxsxKFDh1gmiUitevXqhatXr2LVqlWoqKiAv78/vL29UVZWJjoaEQslkTp8+OGHmDx5Mlq1aoWUlBT4+PiIjkREOuq1115DQUEBBg8ejPj4eHTq1AkxMTGiY5Ge45I3kYrmzZuHL774Ah07dkR6ejq6dOkiOhIR6Yndu3cjIiIC5eXl6NmzJ+Li4tCjRw/RsUgPcUJJ9JiUSiUCAwPxxRdfoEePHsjJyWGZJKIWFRISArlcjkmTJuHSpUtwcnLCiy++yIt2qMVxQkn0GBQKBdzd3ZGSkoLBgwfj6NGjkEj4+xkRiZOSkoKxY8ciLy8PlpaWiI2NxYgRI0THIj3Bn4BETXTr1i04ODggJSUF4eHhOHbsGMskEQnXr18/XL9+HW+++SZKS0sxcuRIjBkzBlVVVaKjkR7gT0GiJsjJyYGdnR2uX7+OV155Bd99953oSEREd1ixYgVu3LiBgQMH4ueff4alpSX3w6Vmx0JJ9IhOnz6Np556CmVlZfjss8/wwQcfiI5ERHRPnTt3xunTp7F9+3ZIJBLMmjULbm5uyM3NFR2NdBQLJdEj+Omnn+Dp6Yn6+nr8+OOPmDdvnuhIREQPNWnSJJSUlCAkJAQZGRmwt7fH0qVLedEOqR0vyiF6iM8//xzz58+HiYkJjh49Cnd3d9GRiIiaLCkpCePGjYNUKkXnzp2xe/dueHl5iY5FOoITSqIHePXVV/Hiiy+iXbt2uHjxIsskEWktDw8P3LhxA6+88gqKioowePBghISEoLa2VnQ00gGcUBLdx8SJE7Fjxw507doVGRkZaN++vehIRERqcf36dQQEBCA9PR1mZmZYu3YtpkyZIjoWaTFOKIn+h1KpxJAhQ7Bjxw7069cP165dY5kkIp3SrVs3pKWlYd26dVAqlZg6dSoGDhwIqVQqOhppKRZKon+oqqqCs7Mzjh8/joCAACQnJ8PIyEh0LCKiZhEVFYXi4mKMGTMGZ86cQdeuXbF8+XLRsUgLccmb6C9SqRRubm6QyWSYO3cuPv/8c9GRiIhazJEjRxAaGori4mI8+eST2Lt3LwYMGCA6FmkJTiiJAGRmZqJHjx6QyWRYtWoVyyQR6Z3hw4ejsLAQ8+fPR35+PgYOHIiJEydCoVCIjkZagBNK0nu///47nn32WTQ0NGDr1q2YNGmS6EhEREJdvXoVAQEBuHDhAtq0aYNNmzYhNDRUdCzSYJxQkl7bvHkzfH19AQDx8fEsk0REABwcHHD+/HnExMSgrq4OYWFh8PLyQnFxsehopKFYKElvvfPOO4iIiICZmRnS09MxbNgw0ZGIiDTK/PnzUVRUBG9vbyQmJqJLly5YtWqV6FikgbjkTXpp1qxZWLduHaysrJCRkYFOnTqJjkREpNEOHjyIiRMnorS0FN27d8e+ffvg4uIiOhZpCE4oSa8olUqMHj0a69atg7OzM3JyclgmiYgewejRo1FcXIyoqCjk5OTAzc0NkZGRvC84AeCEkvRIXV0dBg4ciIyMDAwfPhy///47JBL+TkVE1FQXLlxAQEAArl69ivbt22P79u3w9/cXHYsE4k9T0gslJSWwt7dHRkYGpk2bhsOHD7NMEhE9pqeeegpXrlzBhx9+iKqqKgQEBGDEiBG4deuW6GgkCH+iks67du0aunfvjvz8fPznP//B5s2bRUciItIJS5cuRUFBAYYMGYIjR46gU6dO+Pjjj0XHIgG45E06LTExESNGjEBdXR2+/PJLzJ49W3QkIiKdtGfPHkybNg3l5eVwcnJCXFwcHB0dRceiFsIJJemsXbt2YciQIVAoFNi/fz/LJBFRMwoODoZcLseUKVOQlZWFnj17Yu7cubxoR09wQkk66eOPP8bixYvRunVrHD9+HP369RMdiYhIb6SlpSEwMBDXr1+HhYUFvv/+e3h7e4uORc2IE0rSOUuWLMHixYvRoUMHXLp0iWWSiKiF9enTB7m5uVi5ciVu3boFHx8fjB49GpWVlaKjUTPhhJJ0SmhoKH744QfY2dkhIyMDbdq0ER2JiEivFRYWIjAwEKdOnYKpqSnWrFnDU5B0EAsl6QSFQoEhQ4bg5MmTGDRoEE6cOAEjIyPRsYiI6C87duxAVFQUKisr0bt3b8TFxcHOzk50LFITLnmT1quoqICTkxNOnjyJcePG4dSpUyyTREQaJjw8HHK5HKGhoTh37hwcHBywZMkSXrSjIzihJK2Wn58PNzc3yOVyLFiwAJ988onoSERE9BCnTp1CcHAwbt68CSsrK/zwww8YMmSI6FikAk4oSWulpaXB0dERcrkc0dHRLJNERFrC3d0d+fn5eO211yCTyTB06FAEBwejpqZGdDR6TJxQklY6ePAgAgMDoVQqsWPHDoSFhYmOREREj+HGjRsICAhAamoqWrduja+++grTpk0THYuaiBNK0jrr16/HmDFjIJFIkJCQwDJJRKTFnnzySaSkpGDjxo1obGzE9OnT0b9/f+Tn54uORk3AQklaZfny5Zg5cybatGmDc+fOwcvLS3QkIiJSgxkzZqCkpAQBAQFISUmBra0t/v3vf4uORY+IS96kNSIiIrB582ZYW1sjIyMDFhYWoiMREVEzSEhIwPjx41FUVAQbGxvs2bMHgwYNEh2LHoATStJ4SqUS3t7e2Lx5M1xcXJCdnc0ySUSkw4YOHQqpVIqFCxdCKpXC3d0dzz33HOrq6kRHo/vghJI0Wk1NDfr3748LFy7A19cXBw8ehETC34OIiPRFdnY2/P39cf78eZibm2PTpk08d14D8SczaSyZTAZ7e3tcuHABkZGROHToEMskEZGe6d69O86dO4fPPvsMCoUCEyZMgKenJ2Qymeho9A/86UwaKSsrC/b29pBKpVi5ciU2bNggOhIREQk0b948yGQy+Pr6IikpCdbW1nj33XdFx6K/cMmbNE5CQgJ8fHxQX1+PjRs3IiIiQnQkIiLSIIcOHUJ4eDhKSkpgZ2eHffv2wdXVVXQsvcYJJWmUHTt2YPjw4VAqlTh06BDLJBER3cXPzw8ymQyzZ89Gbm4u+vTpg+nTp0OhUIiOprc4oSSN8d///hevvPIKzMzMkJSUxN82iYjooS5evIiAgABcuXIF7dq1w7Zt2xAYGCg6lt7hhJI0wvz58/HKK6/A0tISV65cYZkkIqJH4uzsjMuXLyM6OhrV1dUYO3Yshg0bhtLSUtHR9AonlCTc2LFjsW/fPjg4OCA9PR1mZmaiIxERkRYqLS1FUFAQjh49CmNjY7z//vtYsmSJ6Fh6gYWShFEoFPDw8MCZM2cwePBgHD16lNsCERGRyvbu3Ytp06ahrKwMjo6OiIuLg5OTk+hYOo0/vUmIsrIy9OjRA2fOnMGECRNw7NgxlkkiIlKLoKAgFBcXY9q0abhy5QqcnZ0xZ84cKJVK0dF0FieU1OJyc3PRt29flJaW4l//+hf++9//io5EREQ6Kj09HYGBgcjNzUWHDh2wc+dO+Pr6io6lczgSohZ15swZODs749atW4iJiWGZJCKiZuXm5oacnBy8/fbbKC8vh5+fH/z8/FBRUQHgzxWzgQMHYvPmzU06bmWtApn5t3A2twSZ+bdQWavfWxZxQkktZt++fRg3bhwAYNeuXQgODhYbiIiI9IpMJkNAQABOnjwJU1NTrF69GufOncOnn36KNm3a4PLly+jcufN9X59VUI5tSbmIv1iIXHkV/lmgDADYWphhpLMVpnjYwqlz22b/ejQJCyW1iC+//BLz5s2DiYkJjh49Cnd3d9GRiIhIT+3cuRPPP/88Kisrb3/O0NAQkyZNwpYtW+56/nV5FZbtTsfRyzIYSgzQoLx/dfr78WccO+K9EDd0s9CPnUtYKKnZvf7663j//ffRvn17pKamws7OTnQkIiLSc5WVlbCxsUFZWdkdnz9y5AiGDRt2++PvTuXizb2ZUCgbH1gk/5ehxABGEgOsDHLBRHdbteXWVEaiA5Bumzx5Mr799lt07doV6enpeOKJJ0RHIiIiwueff35XmQSAqVOn4sqVKzA2Nsan8Vn46JdLj3X8hr8K6Gs/pENWUYv5I3V72yJelEPNQqlUYujQofj222/Rt29fXLt2jWWSiIg0Rmxs7B0f/7113fXr1/HMM89gW2L2Y5fJ//XRL5ew41SuWo6lqbjkTWpXVVWFfv36ISsrC/7+/vjpp5+4xyQREWmU8vJyXLp0CVKpFDdv3sTNmzeRlZWFn376CRVoha6zv0Sj5O6F3LrCbJQlxaJWehkNFSVorK+BxNQcJlbd0abPKJi7jLjn+5kaSfDr4uE6e04lCyWpVWFhIVxdXVFUVIQ5c+bgyy+/FB2JiIioSYJWH0JGYS2UMLjrsYqMeBTvi77va58YPh3tvZ676/OGEgMMdrDEligPtWbVFDyHktTm/PnzcHd3R2VlJd577z28/vrroiMRERE1SVZBOdIK64B7lEkAMGzdBm36joZpN1cYtukAZU0Fyk/9iNobFwAA5ad/umehbFA24uhlGS4XlsPRSve2FGKhJLWIj4/H6NGj0dDQgK1bt2LKlCmiIxERETXZtqTcB24N1LqHO1r3uHPrO+MONri5cQEAQFlXfd9jG0oMsDUxFyuCXNQXWEPwxDZS2datW+Hj4wMA+O2331gmiYhIa8VfLHzk7YEaG5VQlBejPOXA7c+1snW77/MblI2Iv1SockZNxAklqeTdd9/Ff/7zH5ibm+PUqVPo1auX6EhERESPpaJWgVx51SM99+bml1GXf/EfnzFA6x6DYOm/8IGvyy2uQmWtAuamulXBdOuroRY1e/ZsfP3117CyskJ6ejqsrKxERyIiInpsOcWVeOwrlQ0MAIkh8JBrnRsBZBdXwsWm/eO+k0ZioaQmUyqV8Pf3x8GDB9GzZ0+kpqaiVatWomMRERGppE6hfOTnWj47H8qaCijKZKg4G4faG+dRnZWIwvJiWM9Yrbb30RYslNQkdXV1GDRoENLT0zFs2DDEx8dzj0kiItIJJkaP/vPMxMr+9p/NnL2Q98lkNCrqUCfNQr38BowtnlTL+2gL3fuKqNmUlpbCwcEB6enpmDJlCo4cOcIySUREOqO7pfl9Ngv6P8r62vs88n+vVNZU3Pf1Bn+9j67hhJIeybVr19CvXz+UlZVh2bJlePfdd0VHIiIiUitzUyPYWpgh5wEX5ki/WQwTG2e06tobhu06QVl1C+Vn9qNR8WfRNDAyhbFlt/u+3tbSTOcuyAFYKOkRJCUlYfjw4airq8NXX32F2bNni45ERETULEY6W2FLUs59tw5S1tWgMu0QKtMO3fPxDt7PQ2J679srGkoMMLKnbl7AyvVKeqDdu3dj8ODBUCgU2LdvH8skERHptCketg/ch7KdRwha2feHYduOgKExYGgEw/adYdZ7ODpPeR9tBwTc97UNykZM9bRtjtjC8V7edF9r1qzBwoUL0apVKxw7dgwDBgwQHYmIiKjZTVufhONXix95g/NHoev38uaEku7p5ZdfxsKFC9GhQwdcvHiRZZKIiPTGeyFuMJI87PKcpjGSGOC9kPvfRUfbsVDSXcLCwvD//t//g52dHXJzc2Frq5vjeSIionvpZmGGlWq+3/ZbQS7oZnHvcyt1AS/KoduUSiUGDx6MpKQkDBw4EImJiTAy4l8RIiLSPxPdbSGrqMVHv1xS+VhLRzkj3F23hzM8h5IAAJWVlejTpw+uXr2K4OBg/Pjjj6IjERERCffdqVy8uTcTCmVjk86pNJQYwEhigLeCXHS+TAIslAQgPz8fffr0QXFxMV566SWsWbNGdCQiIiKNcV1ehWW703H0sgyGEoMHFsu/H3/GsSPeC3HT6WXuf2Kh1HPp6enw8PBAdXU1PvroI7z88suiIxEREWmkrIJybEvKRfylQuQWV+GfBcoAf25aPrKnFaZ62sLRqq2omEKwUOqxQ4cOwd/fH0qlEt9++y2ee+450ZGIiIi0QmWtAtnFlahTKGFiJEF3S3OdvAPOo2Kh1FMbN25EVFQUjI2N8fvvv2PIkCGiIxEREZGW4rZBemjFihV4/vnn0aZNG2RkZLBMEhERkUr0dzarJ8rKytCuXbvbH0dGRmLTpk3o0qULMjMzYWFhITAdERER6QJOKHXYt99+C0tLS+zfvx9KpRI+Pj7YtGkTevfujZycHJZJIiIiUgueQ6nDnn76aZw6dQomJiawsbFBdnY2fHx88Msvv0Ai4e8SREREpB4slFqiqVeTZWRkwM3tznuGjh8/Hrt27WruqERERKRneA6lBru939XFQuTK77HflYUZRjpbYYqHLZw637nf1dq1ayGRSKBUKv98voEBTp8+jYKCAnTu3LnlvggiIiLSeZxQaiBVd+Svrq6GpaUlqqur73p+REQENm3a1IzpiYiISN9wQqlh/nnPUAAPvW/o348fv1oM39VHsDLIBSe2Rt9VJnv37g1/f3/MnDmzeYITERGR3uKEUoN8Gp+Fj365pPJxbh3ditJj32Hs2LEIDw+Hr68vl7mJiIio2bBQaojvTuXitR/S1Xa8lf5OiHimp9qOR0RERHQ/LJQa4Lq8Cr6rj6BWobzrsTrpFVReOIra6xlQ3CpEQ1UZJKZmMLVxRjvPULTq5nrPY5oaSfDr4uHoZmHW3PGJiIhIz3EzQg2wbHf67XMm/1d5ygGUJcai9sYFNFTIAaUCyuoyVF85hYLty1B18fg9X6dQNmLZbvVNPImIiIjuhxflCJZVUI6jl2UPfI6heQeY9x2FVl17Q1lTgdKEb6GQ5wGNSsh/Wwcz58F3vaZB2Yijl2W4XFgOR6u29zgqERERkXqwUAq2LSn3gVsDmbuMRAefmZAYt7r9OWPLbri5cQEAoKGsEA2VpTA0f+Ku1xpKDLA1MRcrglyaJTsRERERwCVv4eIvFj5wa6BW3VzuKJMAYGRhc8fHBsam93xtg7IR8ZcKVQ9JRERE9AAslAJV1CqQK69q8uv+ed6kaVcXSExa3/e5ucVVqKxVPFY+IiIiokfBQilQTnElmnqJfa30MuSHvvrzA0NjdPCd9cDnNwLILq58rHxEREREj4LnUApUd49tgh6k5nomCmNXorG2CpAYolPQUph2cVT7+xARERE1BQulQCZGjz4grr52BkU/vIvG+lrA0Bidgl+FWU9Ptb8PERERUVOxUArU3dIcBsBDl72rLh5H0d4PgQYFDIxboVPof9C6e79Heg+Dv96HiIiIqLmwUApkbmoEWwsz5DzgwpzKCwmQ7fkQaFQCMED7oZNgYGiMmuuZt59jat0TBkbG93y9raUZzE35fzMRERE1HzYNwUY6W2FLUs59tw6qvnzqrzIJAI0ojd9413OefGE9jJ7ofNfnDSUGGNnTSp1xiYiIiO7Ck+sEm+Jh+8B9KFXRoGzEVE/bZjk2ERER0d8MGhsbm6fN0CObtj4Jx68Wq7VYGkoMMNjBEluiPNR2TCIiIqJ74YRSA7wX4gYjiYFaj2kkMcB7IW5qPSYRERHRvbBQaoBuFmZYqeb7bb8V5IJuFmZqPSYRERHRvbBQaoiJ7rb416ieajnW0lHOCHfnuZNERETUMngOpYb57lQu3tybCYWysUnnVBpKDGAkMcBbQS4sk0RERNSiWCg10HV5FZbtTsfRyzIYSgweWCz/fvwZx454L8SNy9xERETU4lgoNVhWQTm2JeUi/lIhcour7rijjgH+3LR8ZE8rTPW0haNVW1ExiYiISM+xUGqJyloFsosrUadQwsRIgu6W5rwDDhEREWkEFkoiIiIiUgmv8iYiIiIilbBQEhEREZFKWCiJiIiISCUslERERESkEhZKIiIiIlIJCyURERERqYSFkoiIiIhUwkJJRERERCphoSQiIiIilbBQEhEREZFKWCiJiIiISCUslERERESkEhZKIiIiIlIJCyURERERqYSFkoiIiIhUwkJJRERERCphoSQiIiIilbBQEhEREZFKWCiJiIiISCUslERERESkEhZKIiIiIlIJCyURERERqYSFkoiIiIhUwkJJRERERCphoSQiIiIilbBQEhEREZFKWCiJiIiISCUslERERESkEhZKIiIiIlIJCyURERERqYSFkoiIiIhUwkJJRERERCphoSQiIiIilbBQEhEREZFKWCiJiIiISCUslERERESkEhZKIiIiIlLJ/wfeRQYZmSmrcgAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -164,7 +164,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -207,7 +207,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -244,7 +244,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -254,7 +254,13 @@
     "    filter_dict={\n",
     "        \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n",
     "    },\n",
-    ")"
+    ")\n",
+    "\n",
+    "#config_list_gpt4 = autogen.config_list_from_json(\"OAI_CONFIG_LIST\",filter_dict={\"model\": [\"gpt-4-1106-preview\"],},)\n",
+    "\n",
+    "if (config_list_gpt4[0].get('api_type') is not None):\n",
+    "    # Pop api_type\n",
+    "    config_list_gpt4[0].pop('api_type')"
    ]
   },
   {
@@ -296,124 +302,38 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We are printing out debug messages so that the reader can understand the conversation flow and select_speaker method better.\n",
-    "\n",
-    "Overrides the `select_speaker` method with custom logic including:\n",
-    "  - Handling of `NEXT:` and `TERMINATE` tags in the last message.\n",
-    "  - Selection of the first-round speaker based on the `first_round_speaker` attribute in the graph nodes.\n",
-    "  - Selection of subsequent speakers based on the successors in the graph of the previous speaker.\n",
-    "  - Random selection of the next speaker from the eligible candidates."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CustomGroupChat(GroupChat):\n",
-    "    def __init__(self, agents, messages, max_round=10, graph=None):\n",
-    "        super().__init__(agents, messages, max_round)\n",
-    "        self.previous_speaker = None  # Keep track of the previous speaker\n",
-    "        self.graph = graph  # The graph depicting who are the next speakers available\n",
-    "\n",
-    "    def select_speaker(self, last_speaker, selector):       \n",
-    "        self.previous_speaker = last_speaker\n",
-    "\n",
-    "        # Check if last message suggests a next speaker or termination\n",
-    "        last_message = self.messages[-1] if self.messages else None\n",
-    "        suggested_next = None\n",
-    "        \n",
-    "        if last_message:\n",
-    "            if 'NEXT:' in last_message['content']:\n",
-    "                suggested_next = last_message['content'].split('NEXT: ')[-1].strip()\n",
-    "                # Strip full stop and comma\n",
-    "                suggested_next = suggested_next.replace('.', '').replace(',', '')\n",
-    "                print(f\"Suggested next speaker from the last message: {suggested_next}\")\n",
-    "                    \n",
-    "            elif 'TERMINATE' in last_message['content']:\n",
-    "                try:\n",
-    "                    return self.agent_by_name('User_proxy')\n",
-    "                except ValueError:\n",
-    "                    print(f\"agent_by_name failed suggested_next: {suggested_next}\")\n",
-    "                \n",
-    "        # Debugging print for the current previous speaker\n",
-    "        if self.previous_speaker is not None:\n",
-    "            print('Current previous speaker:', self.previous_speaker.name)\n",
-    "\n",
-    "        # Selecting first round speaker\n",
-    "        if self.previous_speaker is None and self.graph is not None:\n",
-    "            eligible_speakers = [agent for agent in agents if self.graph.nodes[agent.name].get('first_round_speaker', False)]\n",
-    "            print('First round eligible speakers:', [speaker.name for speaker in eligible_speakers])\n",
-    "\n",
-    "        # Selecting successors of the previous speaker\n",
-    "        elif self.previous_speaker is not None and self.graph is not None:\n",
-    "            eligible_speaker_names = [target for target in self.graph.successors(self.previous_speaker.name)]\n",
-    "            eligible_speakers = [agent for agent in agents if agent.name in eligible_speaker_names]\n",
-    "            print('Eligible speakers based on previous speaker:', eligible_speaker_names)\n",
-    "\n",
-    "        else:\n",
-    "            eligible_speakers = agents\n",
-    "\n",
-    "        # Debugging print for the next potential speakers\n",
-    "        print(f\"Eligible speakers based on graph and previous speaker {self.previous_speaker.name if self.previous_speaker else 'None'}: {[speaker.name for speaker in eligible_speakers]}\")\n",
-    "\n",
-    "        # Three attempts at getting the next_speaker\n",
-    "        # 1. Using suggested_next if suggested_next is in the eligible_speakers.name\n",
-    "        # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message\n",
-    "        # 3. Random (catch-all)\n",
-    "        next_speaker = None\n",
-    "        \n",
-    "        if eligible_speakers:\n",
-    "            print(\"Selecting from eligible speakers:\", [speaker.name for speaker in eligible_speakers])\n",
-    "            # 1. Using suggested_next if suggested_next is in the eligible_speakers.name\n",
-    "            if suggested_next in [speaker.name for speaker in eligible_speakers]:\n",
-    "                print(\"suggested_next is in eligible_speakers\")\n",
-    "                next_speaker = self.agent_by_name(suggested_next)\n",
-    "                \n",
-    "            else:\n",
-    "                msgs_len = len(self.messages)\n",
-    "                print(f\"msgs_len is now {msgs_len}\")\n",
-    "                if len(self.messages) > 1:\n",
-    "                    # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message\n",
-    "                    print(f\"Using LLM to pick from eligible_speakers: {[speaker.name for speaker in eligible_speakers]}\")\n",
-    "                    selector.update_system_message(self.select_speaker_msg(eligible_speakers))\n",
-    "                    _, name = selector.generate_oai_reply(self.messages + [{\n",
-    "                        \"role\": \"system\",\n",
-    "                        \"content\": f\"Read the above conversation. Then select the next role from {[agent.name for agent in eligible_speakers]} to play. Only return the role.\",\n",
-    "                    }])\n",
-    "\n",
-    "                    # If exactly one agent is mentioned, use it. Otherwise, leave the OAI response unmodified\n",
-    "                    mentions = self._mentioned_agents(name, eligible_speakers)\n",
-    "                    if len(mentions) == 1:\n",
-    "                        name = next(iter(mentions))\n",
-    "                        next_speaker = self.agent_by_name(name)\n",
-    "\n",
-    "                if next_speaker is None:\n",
-    "                    # 3. Random (catch-all)\n",
-    "                    next_speaker = random.choice(eligible_speakers)\n",
-    "                    \n",
-    "                \n",
-    "            print(f\"Selected next speaker: {next_speaker.name}\")\n",
-    "\n",
-    "            return next_speaker\n",
-    "        else:\n",
-    "            # Cannot return next_speaker with no eligible speakers\n",
-    "            raise ValueError(\"No eligible speakers found based on the graph constraints.\")"
+    "## Demonstration"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Demonstration"
+    "### Team Operations\n"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 8,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "### Team Operations\n"
+    "# Termination message detection\n",
+    "def is_termination_msg(content) -> bool:\n",
+    "    have_content = content.get(\"content\", None) is not None\n",
+    "    if have_content and \"TERMINATE\" in content[\"content\"]:\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "# Terminates the conversation when TERMINATE is detected.\n",
+    "user_proxy = autogen.UserProxyAgent(\n",
+    "        name=\"User_proxy\",\n",
+    "        system_message=\"Terminator admin.\",\n",
+    "        code_execution_config=False,\n",
+    "        is_termination_msg=is_termination_msg,\n",
+    "        human_input_mode=\"NEVER\")\n",
+    "\n",
+    "agents = [user_proxy]\n"
    ]
   },
   {
@@ -423,7 +343,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x1000 with 1 Axes>"
       ]
@@ -439,7 +359,9 @@
     "# Create an empty directed graph\n",
     "graph = nx.DiGraph()\n",
     "\n",
-    "agents = []\n",
+    "# Add user_proxy node\n",
+    "graph.add_node(user_proxy.name, label=user_proxy.name, secret_value=None)\n",
+    "\n",
     "\n",
     "# Outer loop for prefixes 'A', 'B', 'C'\n",
     "for prefix in ['A', 'B', 'C']:\n",
@@ -494,9 +416,16 @@
     "graph.add_edge('C0', 'A0')\n",
     "graph.add_edge('C0', 'B0')\n",
     "\n",
+    "# Connecting team lead to User_proxy and vice versa\n",
+    "graph.add_edge('A0', 'User_proxy')\n",
+    "graph.add_edge('B0', 'User_proxy')\n",
+    "graph.add_edge('C0', 'User_proxy')\n",
+    "graph.add_edge('User_proxy', 'A0')\n",
+    "graph.add_edge('User_proxy', 'B0')\n",
+    "graph.add_edge('User_proxy', 'C0')\n",
     "\n",
-    "# Updating node A0\n",
-    "graph.nodes['A0']['first_round_speaker'] = True\n",
+    "# Updating node User_proxy\n",
+    "graph.nodes['User_proxy']['first_round_speaker'] = True\n",
     "\n",
     "def get_node_color(node):\n",
     "    if graph.nodes[node].get('first_round_speaker', False):\n",
@@ -520,227 +449,236 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 10,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Termination message detection\n",
-    "def is_termination_msg(content) -> bool:\n",
-    "    have_content = content.get(\"content\", None) is not None\n",
-    "    if have_content and \"TERMINATE\" in content[\"content\"]:\n",
-    "        return True\n",
-    "    return False\n",
-    "\n",
-    "# Terminates the conversation when TERMINATE is detected.\n",
-    "user_proxy = autogen.UserProxyAgent(\n",
-    "        name=\"User_proxy\",\n",
-    "        system_message=\"Terminator admin.\",\n",
-    "        code_execution_config=False,\n",
-    "        is_termination_msg=is_termination_msg,\n",
-    "        human_input_mode=\"NEVER\")\n",
-    "\n",
-    "agents.append(user_proxy)"
+    "## Implementation"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33mA0\u001b[0m (to chat_manager):\n",
+      "\u001b[33mUser_proxy\u001b[0m (to chat_manager):\n",
       "\n",
       "\n",
       "                        There are 9 players in this game, split equally into Teams A, B, C. Therefore each team has 3 players, including the team leader. \n",
-      "                        The task is to find out the sum of chocolate count from all nine players. I will now start with my team. \n",
-      "                        NEXT: A1\n",
+      "                        The task is to find out the sum of chocolate count from all nine players. I will now start with my team A leader. \n",
+      "                        NEXT: A0\n",
+      "\n",
+      "--------------------------------------------------------------------------------\n",
+      "\u001b[33mA0\u001b[0m (to chat_manager):\n",
+      "\n",
+      "As the team leader of Team A, my task is to gather the total chocolate count of my team. My individual count is 4 chocolates. I'll need to check with A1 and A2 for their counts.\n",
+      "\n",
+      "Before checking with my teammates, the tally is as follows:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:?, A2:?,\n",
+      "B0:?, B1:?, B2:?,\n",
+      "C0:?, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "Now, let's see how many chocolates A1 has.\n",
+      "NEXT: A1\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: A1\n",
-      "Current previous speaker: A0\n",
-      "Eligible speakers based on previous speaker: ['A1', 'A2', 'B0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker A0: ['A1', 'A2', 'B0', 'C0']\n",
-      "Selecting from eligible speakers: ['A1', 'A2', 'B0', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: A1\n",
       "\u001b[33mA1\u001b[0m (to chat_manager):\n",
       "\n",
-      "As A1 I have 1 chocolate right now. Our team leader A0, please note my count.\n",
+      "I am A1, and I have 4 chocolates. \n",
       "\n",
+      "Updating the tally for Team A with my count:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:?,\n",
+      "B0:?, B1:?, B2:?,\n",
+      "C0:?, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "Let's find out how many chocolates A2 has.\n",
       "NEXT: A2\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: A2\n",
-      "Current previous speaker: A1\n",
-      "Eligible speakers based on previous speaker: ['A0', 'A2']\n",
-      "Eligible speakers based on graph and previous speaker A1: ['A0', 'A2']\n",
-      "Selecting from eligible speakers: ['A0', 'A2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: A2\n",
       "\u001b[33mA2\u001b[0m (to chat_manager):\n",
       "\n",
-      "As part of Team A, I have 2 chocolates at the moment.\n",
+      "As A2, I have 2 chocolates. I can now update the tally for Team A with my count:\n",
       "\n",
-      "Now that each member of Team A has reported their tally, our team leader A0 should be able to calculate and report our team's total sum to the other team leaders. \n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:?, B1:?, B2:?,\n",
+      "C0:?, C1:?, C2:?\n",
+      "```\n",
       "\n",
-      "NEXT: A0.\n",
+      "Now that I've reported my count, the team leader A0 can tally our team's total. So I suggest our team leader next.\n",
+      "\n",
+      "NEXT: A0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: A0\n",
-      "Current previous speaker: A2\n",
-      "Eligible speakers based on previous speaker: ['A0', 'A1']\n",
-      "Eligible speakers based on graph and previous speaker A2: ['A0', 'A1']\n",
-      "Selecting from eligible speakers: ['A0', 'A1']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: A0\n",
       "\u001b[33mA0\u001b[0m (to chat_manager):\n",
       "\n",
-      "I, A0, have 4 chocolates, A1 reported having 1 chocolate, and A2 reported having 2 chocolates. So the total chocolate count for Team A is 4 + 1 + 2 = 7 chocolates. \n",
+      "As the team leader A0, with the reports from A1 and A2, I can now confirm our team's chocolate count and tally our total.\n",
       "\n",
-      "I'm saving this in our JSON format as: \n",
-      "A0:4, A1:1, A2:2,\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
       "B0:?, B1:?, B2:?,\n",
       "C0:?, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "That makes our team's total 10 chocolates. With Team A's tally accounted for, I suggest that we should find the tally from Team B's leader next.\n",
       "\n",
-      "Let's move on to Team B for their counts.\n",
-      "NEXT: B0.\n",
+      "NEXT: B0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B0\n",
-      "Current previous speaker: A0\n",
-      "Eligible speakers based on previous speaker: ['A1', 'A2', 'B0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker A0: ['A1', 'A2', 'B0', 'C0']\n",
-      "Selecting from eligible speakers: ['A1', 'A2', 'B0', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B0\n",
       "\u001b[33mB0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B0, the team leader of Team B, I already have my count which is 5 chocolates. Now, I will ask the other members of my team to report their counts. \n",
+      "As team leader B0, it's my turn to gather the total chocolate count of my team. I personally have 1 chocolate. Now, I need to find out how many chocolates B1 and B2 have to complete our team's tally.\n",
+      "\n",
+      "The current tally, including the total from Team A, is:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:?, B2:?,\n",
+      "C0:?, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "I'll now check with B1.\n",
       "\n",
       "NEXT: B1\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B1\n",
-      "Current previous speaker: B0\n",
-      "Eligible speakers based on previous speaker: ['B1', 'B2', 'A0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker B0: ['A0', 'B1', 'B2', 'C0']\n",
-      "Selecting from eligible speakers: ['A0', 'B1', 'B2', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B1\n",
       "\u001b[33mB1\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B1, I have 4 chocolates currently. It's now time for our team member B2 to report their count. \n",
+      "I am B1, and I have 4 chocolates. \n",
       "\n",
-      "NEXT: B2.\n",
+      "The updated tally for Team B, including my count:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:?,\n",
+      "C0:?, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "We need to ask B2 for their count to finalize our team's total.\n",
+      "\n",
+      "NEXT: B2\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B2\n",
-      "Current previous speaker: B1\n",
-      "Eligible speakers based on previous speaker: ['B0', 'B2']\n",
-      "Eligible speakers based on graph and previous speaker B1: ['B0', 'B2']\n",
-      "Selecting from eligible speakers: ['B0', 'B2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B2\n",
       "\u001b[33mB2\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B2, I have 1 chocolate right now. Our team leader B0, please note my count.\n",
+      "I'm B2, and I have 2 chocolates. This is the updated tally for Team B with my count:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:2,\n",
+      "C0:?, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "With my report, our team leader B0 can now calculate Team B's total chocolate count. So, I suggest our team leader to go next.\n",
       "\n",
-      "NEXT: B0.\n",
+      "NEXT: B0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: B0\n",
-      "Current previous speaker: B2\n",
-      "Eligible speakers based on previous speaker: ['B0', 'B1']\n",
-      "Eligible speakers based on graph and previous speaker B2: ['B0', 'B1']\n",
-      "Selecting from eligible speakers: ['B0', 'B1']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: B0\n",
       "\u001b[33mB0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As B0, I acknowledge receipt of both B1 and B2's counts. I have 5 chocolates, B1 has 4 and B2 has 1. Adding these counts together, Team B has a total of 5 + 4 + 1 = 10 chocolates.\n",
+      "Thank you, B1 and B2, for your updates. As team leader B0, I can now tally our team's chocolate count.\n",
       "\n",
-      "Updating the JSON tally:\n",
-      "A0:4, A1:1, A2:2,\n",
-      "B0:5, B1:4, B2:1,\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:2,\n",
       "C0:?, C1:?, C2:?\n",
+      "```\n",
       "\n",
-      "Now it's time for Team C to share their counts. \n",
+      "That brings Team B's total to 7 chocolates. With Team A's and Team B's tally accounted for, it is now time to find out the tally from Team C's leader.\n",
       "\n",
-      "NEXT: C0.\n",
+      "NEXT: C0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C0\n",
-      "Current previous speaker: B0\n",
-      "Eligible speakers based on previous speaker: ['B1', 'B2', 'A0', 'C0']\n",
-      "Eligible speakers based on graph and previous speaker B0: ['A0', 'B1', 'B2', 'C0']\n",
-      "Selecting from eligible speakers: ['A0', 'B1', 'B2', 'C0']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C0\n",
       "\u001b[33mC0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C0, I currently have 2 chocolates. I will need the counts from C1 and C2 to complete our team's tally. \n",
+      "As team leader C0, my task now is to tally the total count of chocolates for my team, Team C. My personal count is 1 chocolate. Next, I need to collect the counts from C1 and C2.\n",
       "\n",
-      "NEXT: C1.\n",
+      "So far, the tally including my own is:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:2,\n",
+      "C0:1, C1:?, C2:?\n",
+      "```\n",
+      "\n",
+      "I will ask C1 next for their count.\n",
+      "\n",
+      "NEXT: C1\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C1\n",
-      "Current previous speaker: C0\n",
-      "Eligible speakers based on previous speaker: ['C1', 'C2', 'A0', 'B0']\n",
-      "Eligible speakers based on graph and previous speaker C0: ['A0', 'B0', 'C1', 'C2']\n",
-      "Selecting from eligible speakers: ['A0', 'B0', 'C1', 'C2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C1\n",
       "\u001b[33mC1\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C1, I have 2 chocolates. C2, please share your count so that our team leader, C0, can calculate our team's total.\n",
+      "I have 2 chocolates.\n",
+      "\n",
+      "Updating the tally for Team C with my count:\n",
       "\n",
-      "NEXT: C2.\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:2,\n",
+      "C0:1, C1:2, C2:?\n",
+      "```\n",
+      "\n",
+      "We now need to find out how many chocolates C2 has in order to complete our team's tally.\n",
+      "\n",
+      "NEXT: C2\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C2\n",
-      "Current previous speaker: C1\n",
-      "Eligible speakers based on previous speaker: ['C0', 'C2']\n",
-      "Eligible speakers based on graph and previous speaker C1: ['C0', 'C2']\n",
-      "Selecting from eligible speakers: ['C0', 'C2']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C2\n",
       "\u001b[33mC2\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C2, I have 5 chocolates. Now our team leader, C0, can calculate our team's total sum.\n",
+      "I am C2, and I have 4 chocolates. Here's the updated tally including my count:\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:2,\n",
+      "C0:1, C1:2, C2:4\n",
+      "```\n",
       "\n",
-      "NEXT: C0.\n",
+      "Now that I've reported my chocolate count, team leader C0 can calculate our team's total count.\n",
+      "\n",
+      "NEXT: C0\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "Suggested next speaker from the last message: C0\n",
-      "Current previous speaker: C2\n",
-      "Eligible speakers based on previous speaker: ['C0', 'C1']\n",
-      "Eligible speakers based on graph and previous speaker C2: ['C0', 'C1']\n",
-      "Selecting from eligible speakers: ['C0', 'C1']\n",
-      "suggested_next is in eligible_speakers\n",
-      "Selected next speaker: C0\n",
       "\u001b[33mC0\u001b[0m (to chat_manager):\n",
       "\n",
-      "As C0, I have 2 chocolates, C1 reported having 2 chocolates, and C2 reported having 5 chocolates. So, the total chocolate count for Team C is 2 + 2 + 5 = 9 chocolates.\n",
+      "With the updates from C1 and C2, as team leader C0, I can now tally our team's chocolate count.\n",
+      "\n",
+      "```\n",
+      "A0:4, A1:4, A2:2,\n",
+      "B0:1, B1:4, B2:2,\n",
+      "C0:1, C1:2, C2:4\n",
+      "```\n",
+      "\n",
+      "Team C's total is 7 chocolates. Having the totals for all three teams A, B, and C, we can now sum up all the counts.\n",
       "\n",
-      "Updating the JSON tally:\n",
-      "A0:4, A1:1, A2:2,\n",
-      "B0:5, B1:4, B2:1,\n",
-      "C0:2, C1:2, C2:5\n",
+      "Team A: 4 + 4 + 2 = 10 chocolates.\n",
+      "Team B: 1 + 4 + 2 = 7 chocolates.\n",
+      "Team C: 1 + 2 + 4 = 7 chocolates.\n",
       "\n",
-      "Let's sum up all the team totals. \n",
+      "The total count for all nine players is:\n",
       "\n",
-      "TERMINATE.\n",
+      "10 (Team A) + 7 (Team B) + 7 (Team C) = 24 chocolates.\n",
+      "\n",
+      "As all team tallies have been accounted for, the task is now complete.\n",
+      "\n",
+      "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n"
      ]
     }
    ],
    "source": [
-    "group_chat = CustomGroupChat(\n",
+    "from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat\n",
+    "\n",
+    "graph_group_chat = GraphGroupChat(\n",
     "    agents=agents,  # Include all agents\n",
     "    messages=[],\n",
     "    max_round=20,\n",
@@ -749,14 +687,14 @@
     "\n",
     "\n",
     "# Create the manager\n",
-    "manager = autogen.GroupChatManager(groupchat=group_chat, llm_config=llm_config)\n",
+    "manager = autogen.GroupChatManager(groupchat=graph_group_chat, llm_config=llm_config)\n",
     "\n",
     "\n",
     "# Initiates the chat with Alice\n",
     "agents[0].initiate_chat(manager, message=\"\"\"\n",
     "                        There are 9 players in this game, split equally into Teams A, B, C. Therefore each team has 3 players, including the team leader. \n",
-    "                        The task is to find out the sum of chocolate count from all nine players. I will now start with my team. \n",
-    "                        NEXT: A1\"\"\")\n",
+    "                        The task is to find out the sum of chocolate count from all nine players. I will now start with my team A leader. \n",
+    "                        NEXT: A0\"\"\")\n",
     "\n"
    ]
   }
diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 03bd585c172a..71933d6aad70 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -1,16 +1,15 @@
 try:
     import networkx as nx
     import matplotlib.pyplot as plt
-
     skip_test = False
 except ImportError:
     skip_test = True
 
 from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat
-from unittest import mock
-import builtins
 import autogen
-import json
+from io import StringIO
+import logging
+
 import sys
 import os
 import pytest
@@ -28,7 +27,7 @@
     OAI_CONFIG_LIST, file_location=KEY_LOC, filter_dict={"api_type": ["openai"]}
 )
 
-# config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
+config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
 
 assert len(config_list) > 0
 
@@ -37,7 +36,7 @@
     sys.platform in ["darwin", "win32"] or skip_test,
     reason="do not run on MacOS or windows or dependency is not installed",
 )
-class TestGraphGroupChatGraphValidity:
+class TestGraphGroupChatGraphValidity(unittest.TestCase):
     def test_graph_with_no_nodes(self):
         agents = [Agent(name="Agent 1"), Agent(name="Agent 2")]
         messages = []
@@ -79,13 +78,62 @@ def test_graph_with_self_loops(self):
         with pytest.raises(ValueError) as excinfo:
             GraphGroupChat(agents, messages, graph, allow_repeat_speaker=False)
         assert "The graph has self-loops, but self.allow_repeat_speaker is False." in str(excinfo.value)
+        
+    def test_warning_isolated_agents(self):
+        # Setup a graph with isolated nodes
+        graph = nx.DiGraph()
+        graph.add_node("Agent1", first_round_speaker=True)
+        graph.add_node("Agent2")
+        graph.add_edge("Agent1", "Agent3")  # Agent2 is isolated
+
+        # Setup agents
+        agents = [Agent(name="Agent1"), Agent(name="Agent2"), Agent(name="Agent3")]
+
+        # Redirect logging output to capture it for the test
+        log_capture_string = StringIO()
+        ch = logging.StreamHandler(log_capture_string)
+        ch.setLevel(logging.WARNING)
+        logging.getLogger().addHandler(ch)
+
+        # Create GraphGroupChat instance
+        chat = GraphGroupChat(agents=agents, messages=[], graph=graph)
+
+        # Check if warning is logged
+        log_contents = log_capture_string.getvalue()
+        self.assertIn("isolated agents", log_contents)
+        
+    def test_warning_agents_not_in_graph(self):
+        # Setup a graph without all agents
+        graph = nx.DiGraph()
+        graph.add_node("Agent1", first_round_speaker=True)
+        graph.add_node("Agent2")
+        # Note: Agent3 is missing from the graph
+        graph.add_edge("Agent1", "Agent2")  # Agent2 is isolated
+
+        # Setup agents including one not in the graph
+        agents = [Agent(name="Agent1"), Agent(name="Agent2"), Agent(name="Agent3")]
+
+        # Redirect logging output to capture it for the test
+        log_capture_string = StringIO()
+        ch = logging.StreamHandler(log_capture_string)
+        ch.setLevel(logging.WARNING)
+        logging.getLogger().addHandler(ch)
+
+        # Create GraphGroupChat instance
+        chat = GraphGroupChat(agents=agents, messages=[], graph=graph)
+
+        # Check if warning is logged
+        log_contents = log_capture_string.getvalue()
+        self.assertIn("agents not in self.agents", log_contents)
+
+
 
 
 @pytest.mark.skipif(
     sys.platform in ["darwin", "win32"] or skip_test,
     reason="do not run on MacOS or windows or dependency is not installed",
 )
-class TestGraphGroupChatSelectSpeaker:
+class TestGraphGroupChatSelectSpeakerThreeAssistantAgents:
     @pytest.fixture(autouse=True)
     def setup(self):
         # The default config list in notebook.
@@ -137,3 +185,70 @@ def test_random_speaker_selection(self):
         with unittest.mock.patch("random.choice", return_value=self.agent2):
             selected_speaker = chat.select_speaker(last_speaker=self.agent3, selector=self.selector)
         assert selected_speaker.name == "bob"
+
+@pytest.mark.skipif(
+    sys.platform in ["darwin", "win32"] or skip_test,
+    reason="do not run on MacOS or windows or dependency is not installed",
+)
+class TestGraphGroupChatSelectSpeakerOneAssistantAgentOneUserProxy:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        # The default config list in notebook.
+        self.llm_config = {"config_list": config_list, "cache_seed": 100}
+
+        # Mock Agents
+        self.agent1 = AssistantAgent(name="alice", llm_config=self.llm_config)
+        # Termination message detection
+        def is_termination_msg(content) -> bool:
+            have_content = content.get("content", None) is not None
+            if have_content and "TERMINATE" in content["content"]:
+                return True
+            return False
+
+        # Terminates the conversation when TERMINATE is detected.
+        self.user_proxy = autogen.UserProxyAgent(
+                name="User_proxy",
+                system_message="Terminator admin.",
+                code_execution_config=False,
+                is_termination_msg=is_termination_msg,
+                human_input_mode="NEVER")
+
+        self.agents = [self.user_proxy, self.agent1]
+        
+        # Create Graph
+        self.graph = nx.DiGraph()
+        
+        # Add nodes for all agents
+        for agent in self.agents:
+            self.graph.add_node(agent.name, first_round_speaker=True)
+        # Add edges between all agents
+        for agent1 in self.agents:
+            for agent2 in self.agents:
+                if agent1 != agent2:
+                    self.graph.add_edge(agent1.name, agent2.name)
+                
+    def test_interaction(self):
+        graph_group_chat = GraphGroupChat(
+            agents=self.agents,  # Include all agents
+            messages=[],
+            max_round=20,
+            graph=self.graph
+        )
+
+
+        # Create the manager
+        manager = autogen.GroupChatManager(groupchat=graph_group_chat, llm_config=self.llm_config)
+
+
+        # Initiates the chat with Alice
+        self.agents[0].initiate_chat(manager, message="""
+                                Ask alice what is the largest single digit prime number.""")
+        
+        # Assert the messages contain 7
+        # don't just check the last message        
+        assert any("7" in message["content"] for message in graph_group_chat.messages)
+        
+        # Assert the messages contain alice
+        assert any("alice" in message["name"] for message in graph_group_chat.messages)
+                
+        
\ No newline at end of file

From 1d2dbc4bcc11bcf370c61171f766635cdc25bca7 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 00:46:29 +0000
Subject: [PATCH 07/26] Documentation addition

---
 website/docs/Use-Cases/agent_chat.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index 1e4c0ed35901..6ad84e833b12 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -76,6 +76,8 @@ By adopting the conversation-driven control with both programming language and n
 - LLM-based function call. In this approach, LLM decides whether or not to call a particular function depending on the conversation status in each inference call.
   By messaging additional agents in the called functions, the LLM can drive dynamic multi-agent conversation. A working system showcasing this type of dynamic conversation can be found in the [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant would automatically resort to an expert using function calls.
 
+- Graph-Based Group Chat. In this approach, a directed graph is input into GraphGroupChat, which inherits from GroupChat. AutoGen will then (1) look for a suggested next speaker by the previous speaker, saving one API call. (2) If there is no suggested spaeker, use the LLM API to suggest the next speaker. (3) Lastly, select a random speaker from the eligible speakers. Eligible speakers are successor nodes (agents) from the previous speaker (agent).
+
 ### Diverse Applications Implemented with AutoGen
 
 The figure below shows six examples of applications built using AutoGen.

From 2efb3f0f40a17705949f60ea921ffa0c836752eb Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 00:50:07 +0000
Subject: [PATCH 08/26] pre-commit formats

---
 autogen/agentchat/contrib/graphgroupchat.py   | 16 +++---
 test/agentchat/contrib/test_graphgroupchat.py | 52 +++++++++----------
 2 files changed, 32 insertions(+), 36 deletions(-)

diff --git a/autogen/agentchat/contrib/graphgroupchat.py b/autogen/agentchat/contrib/graphgroupchat.py
index f515ee648ce4..4767c922d5aa 100644
--- a/autogen/agentchat/contrib/graphgroupchat.py
+++ b/autogen/agentchat/contrib/graphgroupchat.py
@@ -78,7 +78,11 @@ def _check_graph_validity(self):
                 raise ValueError("The graph has no edges.")
 
             # Check 3. The graph has at least one node with 'first_round_speaker' set to True
-            first_round_speakers = [agent for agent in self.agents if agent.name in self.graph.nodes and self.graph.nodes[agent.name].get("first_round_speaker", False)]
+            first_round_speakers = [
+                agent
+                for agent in self.agents
+                if agent.name in self.graph.nodes and self.graph.nodes[agent.name].get("first_round_speaker", False)
+            ]
             if not first_round_speakers:
                 raise ValueError("The graph has no nodes with 'first_round_speaker' set to True.")
 
@@ -87,20 +91,18 @@ def _check_graph_validity(self):
                 [self.graph.has_edge(agent.name, agent.name) for agent in self.agents]
             ):
                 raise ValueError("The graph has self-loops, but self.allow_repeat_speaker is False.")
-            
+
             # Check 5. Warning if there are isolated agent nodes
             if any([self.graph.degree(agent.name) == 0 for agent in self.agents]):
                 # Name the isolated agents
                 isolated_agents = [agent.name for agent in self.agents if self.graph.degree(agent.name) == 0]
                 logging.warning(f"The graph has isolated agents: {isolated_agents}")
-                
+
             # Check 6. Warning if there are any agents in self.agents not in graph
             if any([agent.name not in self.graph.nodes for agent in self.agents]):
                 # Name the agents not in the graph
                 agents_not_in_graph = [agent.name for agent in self.agents if agent.name not in self.graph.nodes]
                 logging.warning(f"The graph has agents not in self.agents: {agents_not_in_graph}")
-                
-                
 
         # Run graph check
         _check_graph_validity(self)
@@ -133,8 +135,6 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age
         else:
             eligible_speakers = self.agents
 
-        
-
         # Three attempts at getting the next_speaker
         # 1. Using suggested_next if suggested_next is in the eligible_speakers.name
         # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
@@ -147,7 +147,6 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age
                 next_speaker = self.agent_by_name(suggested_next)
 
             else:
-                msgs_len = len(self.messages)
                 if len(self.messages) > 1:
                     # 2. Using LLM to pick from eligible_speakers, given that there is some context in self.message
                     next_speaker, self.agents, last_speaker, selector = self.auto_select_speaker(
@@ -158,7 +157,6 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age
                     # 3. Random (catch-all)
                     next_speaker = random.choice(eligible_speakers)
 
-
             return next_speaker
         else:
             # Cannot return next_speaker with no eligible speakers
diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 71933d6aad70..12bc47954c20 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -1,6 +1,7 @@
 try:
     import networkx as nx
     import matplotlib.pyplot as plt
+
     skip_test = False
 except ImportError:
     skip_test = True
@@ -78,7 +79,7 @@ def test_graph_with_self_loops(self):
         with pytest.raises(ValueError) as excinfo:
             GraphGroupChat(agents, messages, graph, allow_repeat_speaker=False)
         assert "The graph has self-loops, but self.allow_repeat_speaker is False." in str(excinfo.value)
-        
+
     def test_warning_isolated_agents(self):
         # Setup a graph with isolated nodes
         graph = nx.DiGraph()
@@ -96,12 +97,12 @@ def test_warning_isolated_agents(self):
         logging.getLogger().addHandler(ch)
 
         # Create GraphGroupChat instance
-        chat = GraphGroupChat(agents=agents, messages=[], graph=graph)
+        GraphGroupChat(agents=agents, messages=[], graph=graph)
 
         # Check if warning is logged
         log_contents = log_capture_string.getvalue()
         self.assertIn("isolated agents", log_contents)
-        
+
     def test_warning_agents_not_in_graph(self):
         # Setup a graph without all agents
         graph = nx.DiGraph()
@@ -120,15 +121,13 @@ def test_warning_agents_not_in_graph(self):
         logging.getLogger().addHandler(ch)
 
         # Create GraphGroupChat instance
-        chat = GraphGroupChat(agents=agents, messages=[], graph=graph)
+        GraphGroupChat(agents=agents, messages=[], graph=graph)
 
         # Check if warning is logged
         log_contents = log_capture_string.getvalue()
         self.assertIn("agents not in self.agents", log_contents)
 
 
-
-
 @pytest.mark.skipif(
     sys.platform in ["darwin", "win32"] or skip_test,
     reason="do not run on MacOS or windows or dependency is not installed",
@@ -186,6 +185,7 @@ def test_random_speaker_selection(self):
             selected_speaker = chat.select_speaker(last_speaker=self.agent3, selector=self.selector)
         assert selected_speaker.name == "bob"
 
+
 @pytest.mark.skipif(
     sys.platform in ["darwin", "win32"] or skip_test,
     reason="do not run on MacOS or windows or dependency is not installed",
@@ -198,6 +198,7 @@ def setup(self):
 
         # Mock Agents
         self.agent1 = AssistantAgent(name="alice", llm_config=self.llm_config)
+
         # Termination message detection
         def is_termination_msg(content) -> bool:
             have_content = content.get("content", None) is not None
@@ -207,17 +208,18 @@ def is_termination_msg(content) -> bool:
 
         # Terminates the conversation when TERMINATE is detected.
         self.user_proxy = autogen.UserProxyAgent(
-                name="User_proxy",
-                system_message="Terminator admin.",
-                code_execution_config=False,
-                is_termination_msg=is_termination_msg,
-                human_input_mode="NEVER")
+            name="User_proxy",
+            system_message="Terminator admin.",
+            code_execution_config=False,
+            is_termination_msg=is_termination_msg,
+            human_input_mode="NEVER",
+        )
 
         self.agents = [self.user_proxy, self.agent1]
-        
+
         # Create Graph
         self.graph = nx.DiGraph()
-        
+
         # Add nodes for all agents
         for agent in self.agents:
             self.graph.add_node(agent.name, first_round_speaker=True)
@@ -226,29 +228,25 @@ def is_termination_msg(content) -> bool:
             for agent2 in self.agents:
                 if agent1 != agent2:
                     self.graph.add_edge(agent1.name, agent2.name)
-                
+
     def test_interaction(self):
         graph_group_chat = GraphGroupChat(
-            agents=self.agents,  # Include all agents
-            messages=[],
-            max_round=20,
-            graph=self.graph
+            agents=self.agents, messages=[], max_round=20, graph=self.graph  # Include all agents
         )
 
-
         # Create the manager
         manager = autogen.GroupChatManager(groupchat=graph_group_chat, llm_config=self.llm_config)
 
-
         # Initiates the chat with Alice
-        self.agents[0].initiate_chat(manager, message="""
-                                Ask alice what is the largest single digit prime number.""")
-        
+        self.agents[0].initiate_chat(
+            manager,
+            message="""
+                                Ask alice what is the largest single digit prime number.""",
+        )
+
         # Assert the messages contain 7
-        # don't just check the last message        
+        # don't just check the last message
         assert any("7" in message["content"] for message in graph_group_chat.messages)
-        
+
         # Assert the messages contain alice
         assert any("alice" in message["name"] for message in graph_group_chat.messages)
-                
-        
\ No newline at end of file

From a34a9e235cd0914ffd3447cbaef630e25122d2cf Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 01:39:08 +0000
Subject: [PATCH 09/26] Added GraphGroupChat Test

---
 .github/workflows/contrib-tests.yml | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/.github/workflows/contrib-tests.yml b/.github/workflows/contrib-tests.yml
index c20596117df1..a8e0cfabface 100644
--- a/.github/workflows/contrib-tests.yml
+++ b/.github/workflows/contrib-tests.yml
@@ -112,3 +112,28 @@ jobs:
         if: matrix.python-version != '3.10'
         run: |
           pytest test/agentchat/contrib/test_gpt_assistant.py
+  GraphGroupChat:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-2019]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install packages and dependencies for all tests
+        run: |
+          python -m pip install --upgrade pip wheel
+          pip install pytest
+      - name: Install packages and dependencies for GraphGroupChat
+        run: |
+          pip install -e .[graphs]
+          pip uninstall -y openai
+      - name: Test GraphGroupChat
+        if: matrix.python-version != '3.10'
+        run: |
+          pytest test/agentchat/contrib/test_graphgroupchat.py

From a356c739be998d46620e43a5c9a40ee6c49cdefd Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 01:42:50 +0000
Subject: [PATCH 10/26] Comment out dev config_list

---
 test/agentchat/contrib/test_graphgroupchat.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 12bc47954c20..3e4a7609024c 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -20,6 +20,7 @@
 from autogen.agentchat.assistant_agent import AssistantAgent
 
 
+
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 from test_assistant_agent import KEY_LOC, OAI_CONFIG_LIST  # noqa: E402
 
@@ -28,7 +29,7 @@
     OAI_CONFIG_LIST, file_location=KEY_LOC, filter_dict={"api_type": ["openai"]}
 )
 
-config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
+#config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
 
 assert len(config_list) > 0
 

From 6f2947da33f5242ad1e3ec3572658bfb1dd5f00f Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 01:44:40 +0000
Subject: [PATCH 11/26] precommit passed

---
 test/agentchat/contrib/test_graphgroupchat.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 3e4a7609024c..3c39f2f8bd06 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -20,7 +20,6 @@
 from autogen.agentchat.assistant_agent import AssistantAgent
 
 
-
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 from test_assistant_agent import KEY_LOC, OAI_CONFIG_LIST  # noqa: E402
 
@@ -29,7 +28,7 @@
     OAI_CONFIG_LIST, file_location=KEY_LOC, filter_dict={"api_type": ["openai"]}
 )
 
-#config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
+# config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
 
 assert len(config_list) > 0
 

From f264f419715bd4abea5b12705f152224c1a00208 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 01:49:32 +0000
Subject: [PATCH 12/26] Removed assert config list

---
 test/agentchat/contrib/test_graphgroupchat.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 3c39f2f8bd06..9dd153ae8a6d 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -30,7 +30,7 @@
 
 # config_list = autogen.config_list_from_json(OAI_CONFIG_LIST, filter_dict={"model": ["dev-oai-gpt4"]})
 
-assert len(config_list) > 0
+# assert len(config_list) > 0
 
 
 @pytest.mark.skipif(

From afb9c957397c60d31b7af6e697f58d575ea489d3 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 01:52:53 +0000
Subject: [PATCH 13/26] Relaxed versions

---
 .github/workflows/contrib-tests.yml | 1 -
 setup.py                            | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/contrib-tests.yml b/.github/workflows/contrib-tests.yml
index a8e0cfabface..10e572fd0925 100644
--- a/.github/workflows/contrib-tests.yml
+++ b/.github/workflows/contrib-tests.yml
@@ -132,7 +132,6 @@ jobs:
       - name: Install packages and dependencies for GraphGroupChat
         run: |
           pip install -e .[graphs]
-          pip uninstall -y openai
       - name: Test GraphGroupChat
         if: matrix.python-version != '3.10'
         run: |
diff --git a/setup.py b/setup.py
index 9c1e1e3bd34d..7cded85c59a2 100644
--- a/setup.py
+++ b/setup.py
@@ -52,7 +52,7 @@
         "retrievechat": ["chromadb", "sentence_transformers", "pypdf", "ipython"],
         "teachable": ["chromadb"],
         "lmm": ["replicate", "pillow"],
-        "graphs": ["networkx~=3.2.1", "matplotlib~=3.8.1"],
+        "graphs": ["networkx", "matplotlib"],
     },
     classifiers=[
         "Programming Language :: Python :: 3",

From c6528341323a27ca35a1a2b6a23c2029acfd75f1 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 01:59:25 +0000
Subject: [PATCH 14/26] Shift test casts to openai workload

---
 .github/workflows/contrib-openai.yml | 24 ++++++++++++++++++++++++
 .github/workflows/contrib-tests.yml  | 24 ------------------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml
index 483f43c48721..5cd8cc431058 100644
--- a/.github/workflows/contrib-openai.yml
+++ b/.github/workflows/contrib-openai.yml
@@ -138,3 +138,27 @@ jobs:
         with:
           file: ./coverage.xml
           flags: unittests
+  GraphGroupChat:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install packages and dependencies for all tests
+        run: |
+          python -m pip install --upgrade pip wheel
+          pip install pytest
+      - name: Install packages and dependencies for GraphGroupChat
+        run: |
+          pip install -e .[graphs]
+      - name: Test GraphGroupChat
+        if: matrix.python-version != '3.10'
+        run: |
+          pytest test/agentchat/contrib/test_graphgroupchat.py
diff --git a/.github/workflows/contrib-tests.yml b/.github/workflows/contrib-tests.yml
index 10e572fd0925..c20596117df1 100644
--- a/.github/workflows/contrib-tests.yml
+++ b/.github/workflows/contrib-tests.yml
@@ -112,27 +112,3 @@ jobs:
         if: matrix.python-version != '3.10'
         run: |
           pytest test/agentchat/contrib/test_gpt_assistant.py
-  GraphGroupChat:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-2019]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install packages and dependencies for all tests
-        run: |
-          python -m pip install --upgrade pip wheel
-          pip install pytest
-      - name: Install packages and dependencies for GraphGroupChat
-        run: |
-          pip install -e .[graphs]
-      - name: Test GraphGroupChat
-        if: matrix.python-version != '3.10'
-        run: |
-          pytest test/agentchat/contrib/test_graphgroupchat.py

From 681bd59e109b95ba9b5bc4beb61eb7ef9fbef6ce Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 03:11:25 +0000
Subject: [PATCH 15/26] Catch two errors

---
 test/agentchat/contrib/test_graphgroupchat.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 9dd153ae8a6d..72869ef3ea53 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -3,9 +3,10 @@
     import matplotlib.pyplot as plt
 
     skip_test = False
-except ImportError:
+except (ModuleNotFoundError, ImportError):
     skip_test = True
 
+
 from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat
 import autogen
 from io import StringIO

From e488e6e3459ae9ca8047863d1e64a2d3124f10e9 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Fri, 24 Nov 2023 03:28:52 +0000
Subject: [PATCH 16/26] try import GraphGroupChat

---
 test/agentchat/contrib/test_graphgroupchat.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/agentchat/contrib/test_graphgroupchat.py b/test/agentchat/contrib/test_graphgroupchat.py
index 72869ef3ea53..9b0dad9c7233 100644
--- a/test/agentchat/contrib/test_graphgroupchat.py
+++ b/test/agentchat/contrib/test_graphgroupchat.py
@@ -1,13 +1,13 @@
 try:
     import networkx as nx
     import matplotlib.pyplot as plt
+    from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat
 
     skip_test = False
 except (ModuleNotFoundError, ImportError):
     skip_test = True
 
 
-from autogen.agentchat.contrib.graphgroupchat import GraphGroupChat
 import autogen
 from io import StringIO
 import logging

From 51e9839a7247a0dd41c0ddb9fffc773467e5edc7 Mon Sep 17 00:00:00 2001
From: Joshua Kim <joshkyh@users.noreply.github.com>
Date: Sat, 25 Nov 2023 13:47:12 +1100
Subject: [PATCH 17/26] Update .github/workflows/contrib-openai.yml

Accept suggestion.

Co-authored-by: Chi Wang <wang.chi@microsoft.com>
---
 .github/workflows/contrib-openai.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml
index 5cd8cc431058..cf8971079a46 100644
--- a/.github/workflows/contrib-openai.yml
+++ b/.github/workflows/contrib-openai.yml
@@ -144,7 +144,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8"]
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python ${{ matrix.python-version }}

From d805d2fc8e3ae97bab53bc99a96e3a85abb91a3b Mon Sep 17 00:00:00 2001
From: Joshua Kim <joshkyh@users.noreply.github.com>
Date: Sat, 25 Nov 2023 13:47:21 +1100
Subject: [PATCH 18/26] Update .github/workflows/contrib-openai.yml

Accept suggestion.

Co-authored-by: Chi Wang <wang.chi@microsoft.com>
---
 .github/workflows/contrib-openai.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml
index cf8971079a46..06b728a6e071 100644
--- a/.github/workflows/contrib-openai.yml
+++ b/.github/workflows/contrib-openai.yml
@@ -159,6 +159,6 @@ jobs:
         run: |
           pip install -e .[graphs]
       - name: Test GraphGroupChat
-        if: matrix.python-version != '3.10'
+        if: matrix.python-version != '3.8'
         run: |
           pytest test/agentchat/contrib/test_graphgroupchat.py

From 3d26f4991f26971cab4fbf47ecabcf703f3f2c25 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Mon, 27 Nov 2023 04:32:40 +0000
Subject: [PATCH 19/26] Resolve conflict

---
 .github/workflows/contrib-openai.yml | 38 ++++++++++++++++++++--------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml
index 06b728a6e071..62b0e2b15ff0 100644
--- a/.github/workflows/contrib-openai.yml
+++ b/.github/workflows/contrib-openai.yml
@@ -138,27 +138,45 @@ jobs:
         with:
           file: ./coverage.xml
           flags: unittests
+
   GraphGroupChat:
-    runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: false
       matrix:
         os: [ubuntu-latest]
         python-version: ["3.8"]
+    runs-on: ${{ matrix.os }}
+    environment: openai1
     steps:
-      - uses: actions/checkout@v3
+      # checkout to pr branch
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
-      - name: Install packages and dependencies for all tests
+      - name: Install packages and dependencies
         run: |
+          docker --version
           python -m pip install --upgrade pip wheel
-          pip install pytest
-      - name: Install packages and dependencies for GraphGroupChat
+          pip install -e .
+          python -c "import autogen"
+          pip install coverage pytest-asyncio
+      - name: Install packages for test when needed
         run: |
-          pip install -e .[graphs]
-      - name: Test GraphGroupChat
-        if: matrix.python-version != '3.8'
+          pip install docker
+      - name: Coverage
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}
+          AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}
+          OAI_CONFIG_LIST: ${{ secrets.OAI_CONFIG_LIST }}
         run: |
-          pytest test/agentchat/contrib/test_graphgroupchat.py
+          coverage run -a -m pytest test/agentchat/contrib/test_graphgroupchat.py
+          coverage xml
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          file: ./coverage.xml
+          flags: unittests

From a8e2f1ed04ea3b85e6caefa3f56b3035d0af4868 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Mon, 27 Nov 2023 04:36:08 +0000
Subject: [PATCH 20/26] Manually insert test for teachable agent

---
 .github/workflows/contrib-openai.yml | 39 +++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml
index 62b0e2b15ff0..373850a69e73 100644
--- a/.github/workflows/contrib-openai.yml
+++ b/.github/workflows/contrib-openai.yml
@@ -138,7 +138,6 @@ jobs:
         with:
           file: ./coverage.xml
           flags: unittests
-
   GraphGroupChat:
     strategy:
       matrix:
@@ -180,3 +179,41 @@ jobs:
         with:
           file: ./coverage.xml
           flags: unittests
+  TeachableAgent:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ["3.11"]
+    runs-on: ${{ matrix.os }}
+    environment: openai1
+    steps:
+      # checkout to pr branch
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install packages and dependencies
+        run: |
+          docker --version
+          python -m pip install --upgrade pip wheel
+          pip install -e .[teachable]
+          python -c "import autogen"
+          pip install coverage
+      - name: Coverage
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}
+          AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}
+          OAI_CONFIG_LIST: ${{ secrets.OAI_CONFIG_LIST }}
+        run: |
+          coverage run -a -m pytest test/agentchat/contrib/test_teachable_agent.py
+          coverage xml
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          file: ./coverage.xml
+          flags: unittests

From d1009d12cdd86bd9837dc0c079d98af4b57e577d Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Mon, 27 Nov 2023 22:49:07 +0000
Subject: [PATCH 21/26] Changes from review

---
 .github/workflows/contrib-openai.yml |  5 +----
 website/docs/Use-Cases/agent_chat.md | 12 +++++++-----
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml
index 373850a69e73..ce84228d6fb9 100644
--- a/.github/workflows/contrib-openai.yml
+++ b/.github/workflows/contrib-openai.yml
@@ -161,10 +161,7 @@ jobs:
           python -m pip install --upgrade pip wheel
           pip install -e .
           python -c "import autogen"
-          pip install coverage pytest-asyncio
-      - name: Install packages for test when needed
-        run: |
-          pip install docker
+          pip install coverage
       - name: Coverage
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index a9638b707a4b..458b90db79b4 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -69,14 +69,16 @@ On the one hand, one can achieve fully autonomous conversations after an initial
 
 #### Static and dynamic conversations
 
-By adopting the conversation-driven control with both programming language and natural language, AutoGen inherently allows dynamic conversation. Dynamic conversation allows the agent topology to change depending on the actual flow of conversation under different input problem instances, while the flow of a static conversation always follows a pre-defined topology. The dynamic conversation pattern is useful in complex applications where the patterns of interaction cannot be predetermined in advance. AutoGen provides two general approaches to achieving dynamic conversation:
+AutoGen, by integrating conversation-driven control utilizing both programming and natural language, inherently supports dynamic conversations. This dynamic nature allows the agent topology to adapt based on the actual conversation flow under varying input problem scenarios. Conversely, static conversations adhere to a predefined topology. Dynamic conversations are particularly beneficial in complex settings where interaction patterns cannot be predetermined.
 
-- Registered auto-reply. With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who the next speaker will be in a group chat setting.
+1. Dynamic Group Chat
+The system enables dynamic group chat through a registered auto-reply function. This function allows initiating conversations with other agents based on the current message and context. A practical example is demonstrated in [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) which illustrates the management of dynamic group chats and the decision process for the next speaker.
 
-- LLM-based function call. In this approach, LLM decides whether or not to call a particular function depending on the conversation status in each inference call.
-  By messaging additional agents in the called functions, the LLM can drive dynamic multi-agent conversation. A working system showcasing this type of dynamic conversation can be found in the [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant would automatically resort to an expert using function calls.
+2. Graph-Based Group Chat
+In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. AutoGen then performs several functions: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) In the absence of a suggestion, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) Lastly, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). Note that for simpler use cases where all nodes are interconnected, `GroupChat` suffices. However, `GraphGroupChat` is useful for more controlled scenarios requiring specific conversation paths.
 
-- Graph-Based Group Chat. In this approach, a directed graph is input into GraphGroupChat, which inherits from GroupChat. AutoGen will then (1) look for a suggested next speaker by the previous speaker, saving one API call. (2) If there is no suggested spaeker, use the LLM API to suggest the next speaker. (3) Lastly, select a random speaker from the eligible speakers. Eligible speakers are successor nodes (agents) from the previous speaker (agent).
+3. LLM-Based Function Call
+Another approach involves LLM-based function calls, where LLM decides if a specific function should be invoked based on the conversation's status during each inference. This approach enables dynamic multi-agent conversations, as seen in scenarios like [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant automatically seeks expertise via function calls.
 
 ### Diverse Applications Implemented with AutoGen
 

From 744c3c1617e9dad49e0ec1098c5b648db733c6d7 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Sun, 3 Dec 2023 10:13:38 +0000
Subject: [PATCH 22/26] Bring back original registered auto-reply

---
 website/docs/Use-Cases/agent_chat.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index 458b90db79b4..198f3ce4b2c1 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -71,11 +71,11 @@ On the one hand, one can achieve fully autonomous conversations after an initial
 
 AutoGen, by integrating conversation-driven control utilizing both programming and natural language, inherently supports dynamic conversations. This dynamic nature allows the agent topology to adapt based on the actual conversation flow under varying input problem scenarios. Conversely, static conversations adhere to a predefined topology. Dynamic conversations are particularly beneficial in complex settings where interaction patterns cannot be predetermined.
 
-1. Dynamic Group Chat
-The system enables dynamic group chat through a registered auto-reply function. This function allows initiating conversations with other agents based on the current message and context. A practical example is demonstrated in [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) which illustrates the management of dynamic group chats and the decision process for the next speaker.
+1. Registered auto-reply
+With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who the next speaker will be in a group chat setting.
 
 2. Graph-Based Group Chat
-In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. AutoGen then performs several functions: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) In the absence of a suggestion, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) Lastly, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). Note that for simpler use cases where all nodes are interconnected, `GroupChat` suffices. However, `GraphGroupChat` is useful for more controlled scenarios requiring specific conversation paths.
+In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. AutoGen then performs several functions: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) In the absence of a suggestion, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) Lastly, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent).
 
 3. LLM-Based Function Call
 Another approach involves LLM-based function calls, where LLM decides if a specific function should be invoked based on the conversation's status during each inference. This approach enables dynamic multi-agent conversations, as seen in scenarios like [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant automatically seeks expertise via function calls.

From a648684083201ff7b7a1a2bf8366bbc14488e3b4 Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Sun, 3 Dec 2023 23:16:55 +0000
Subject: [PATCH 23/26] Regroup Registered Auto Reply and Clarify
 GraphGroupChat

---
 website/docs/Use-Cases/agent_chat.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index 198f3ce4b2c1..768f9a50e3a4 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -72,12 +72,13 @@ On the one hand, one can achieve fully autonomous conversations after an initial
 AutoGen, by integrating conversation-driven control utilizing both programming and natural language, inherently supports dynamic conversations. This dynamic nature allows the agent topology to adapt based on the actual conversation flow under varying input problem scenarios. Conversely, static conversations adhere to a predefined topology. Dynamic conversations are particularly beneficial in complex settings where interaction patterns cannot be predetermined.
 
 1. Registered auto-reply
-With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who the next speaker will be in a group chat setting.
+With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who the next speaker will be in a group chat setting. For example:
+- Hierarchical chat like in [OptiGuide](https://github.com/microsoft/optiguide).
+- Dynamic Group Chat which is a special form of hierarchical chat.
+- Graph based group chat which is a special form of dynamic group chat. In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. `GraphGroupChat` takes the following steps in sequence to determine the next speaker: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) If the suggestion from the previous step is not valid, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) If the suggestion from the previous step is not valid, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). A valid suggestion is a transition path that is specified in the directed graph.
+- Nested chat like in [conversational chess](https://github.com/microsoft/autogen/blob/7a4ba1a732ae29cb3d5c9a1b30724a4ba6891ca6/notebook/agentchat_chess.ipynb).
 
-2. Graph-Based Group Chat
-In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. AutoGen then performs several functions: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) In the absence of a suggestion, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) Lastly, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent).
-
-3. LLM-Based Function Call
+2. LLM-Based Function Call
 Another approach involves LLM-based function calls, where LLM decides if a specific function should be invoked based on the conversation's status during each inference. This approach enables dynamic multi-agent conversations, as seen in scenarios like [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant automatically seeks expertise via function calls.
 
 ### Diverse Applications Implemented with AutoGen

From 3d1daf84d757144a1f60da9d5ed99447a6d0330f Mon Sep 17 00:00:00 2001
From: Joshua Kim <joshkyh@users.noreply.github.com>
Date: Mon, 4 Dec 2023 10:54:09 +1100
Subject: [PATCH 24/26] Update website/docs/Use-Cases/agent_chat.md

Co-authored-by: Chi Wang <wang.chi@microsoft.com>
---
 website/docs/Use-Cases/agent_chat.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index 768f9a50e3a4..311eb3369db3 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -76,7 +76,7 @@ With the pluggable auto-reply function, one can choose to invoke conversations w
 - Hierarchical chat like in [OptiGuide](https://github.com/microsoft/optiguide).
 - Dynamic Group Chat which is a special form of hierarchical chat.
 - Graph based group chat which is a special form of dynamic group chat. In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. `GraphGroupChat` takes the following steps in sequence to determine the next speaker: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) If the suggestion from the previous step is not valid, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) If the suggestion from the previous step is not valid, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). A valid suggestion is a transition path that is specified in the directed graph.
-- Nested chat like in [conversational chess](https://github.com/microsoft/autogen/blob/7a4ba1a732ae29cb3d5c9a1b30724a4ba6891ca6/notebook/agentchat_chess.ipynb).
+- Nested chat like in [conversational chess](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_chess.ipynb).
 
 2. LLM-Based Function Call
 Another approach involves LLM-based function calls, where LLM decides if a specific function should be invoked based on the conversation's status during each inference. This approach enables dynamic multi-agent conversations, as seen in scenarios like [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant automatically seeks expertise via function calls.

From ecb4dd6f05d3a11135122dda889937148bd4f2bf Mon Sep 17 00:00:00 2001
From: Joshua Kim <joshkyh@users.noreply.github.com>
Date: Mon, 4 Dec 2023 10:54:30 +1100
Subject: [PATCH 25/26] Update website/docs/Use-Cases/agent_chat.md

Co-authored-by: Chi Wang <wang.chi@microsoft.com>
---
 website/docs/Use-Cases/agent_chat.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index 311eb3369db3..db0084982261 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -72,9 +72,9 @@ On the one hand, one can achieve fully autonomous conversations after an initial
 AutoGen, by integrating conversation-driven control utilizing both programming and natural language, inherently supports dynamic conversations. This dynamic nature allows the agent topology to adapt based on the actual conversation flow under varying input problem scenarios. Conversely, static conversations adhere to a predefined topology. Dynamic conversations are particularly beneficial in complex settings where interaction patterns cannot be predetermined.
 
 1. Registered auto-reply
-With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who the next speaker will be in a group chat setting. For example:
+With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. For example:
 - Hierarchical chat like in [OptiGuide](https://github.com/microsoft/optiguide).
-- Dynamic Group Chat which is a special form of hierarchical chat.
+- [Dynamic Group Chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) which is a special form of hierarchical chat. In the system, we register a reply function in the group chat manager, which broadcasts messages and decides who the next speaker will be in a group chat setting.
 - Graph based group chat which is a special form of dynamic group chat. In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. `GraphGroupChat` takes the following steps in sequence to determine the next speaker: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) If the suggestion from the previous step is not valid, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) If the suggestion from the previous step is not valid, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). A valid suggestion is a transition path that is specified in the directed graph.
 - Nested chat like in [conversational chess](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_chess.ipynb).
 

From 810faa5525bbfb4448fcacf25002dbd9dcd8df3f Mon Sep 17 00:00:00 2001
From: Joshua Kim <kim.yee.haun@gmail.com>
Date: Sun, 3 Dec 2023 23:59:13 +0000
Subject: [PATCH 26/26] Corrected GroupGroupChat link

---
 website/docs/Use-Cases/agent_chat.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md
index db0084982261..f76b4ffc8a59 100644
--- a/website/docs/Use-Cases/agent_chat.md
+++ b/website/docs/Use-Cases/agent_chat.md
@@ -75,7 +75,7 @@ AutoGen, by integrating conversation-driven control utilizing both programming a
 With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. For example:
 - Hierarchical chat like in [OptiGuide](https://github.com/microsoft/optiguide).
 - [Dynamic Group Chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) which is a special form of hierarchical chat. In the system, we register a reply function in the group chat manager, which broadcasts messages and decides who the next speaker will be in a group chat setting.
-- Graph based group chat which is a special form of dynamic group chat. In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), an inherited class of `GroupChat`. `GraphGroupChat` takes the following steps in sequence to determine the next speaker: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) If the suggestion from the previous step is not valid, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) If the suggestion from the previous step is not valid, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). A valid suggestion is a transition path that is specified in the directed graph.
+- Graph based group chat which is a special form of dynamic group chat. In this approach, a directed graph is fed into [GraphGroupChat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb), an inherited class of `GroupChat`. `GraphGroupChat` takes the following steps in sequence to determine the next speaker: (1) It seeks a speaker suggestion from the previous speaker, thereby reducing API calls. (2) If the suggestion from the previous step is not valid, it utilizes the LLM API to nominate the next speaker amongst the eligible speakers. (3) If the suggestion from the previous step is not valid, it randomly selects from eligible speakers, defined as successor nodes (agents) from the prior speaker (agent). A valid suggestion is a transition path that is specified in the directed graph.
 - Nested chat like in [conversational chess](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_chess.ipynb).
 
 2. LLM-Based Function Call