Merge branch 'microsoft:main' into shebang-python

Author: gunnarku

.github/workflows/openai.yml

@@ -11,6 +11,7 @@ on:
       - "test/**"
       - "notebook/agentchat_auto_feedback_from_code_execution.ipynb"
       - "notebook/agentchat_function_call.ipynb"
+      - "notebook/agentchat_groupchat_finite_state_machine.ipynb"
       - ".github/workflows/openai.yml"
 permissions: {}
     # actions: read

.pre-commit-config.yaml

@@ -47,5 +47,6 @@ repos:
     rev: 1.7.1
     hooks:
       - id: nbqa-ruff
-        args: ["--fix"]
+        # Don't require notebooks to have all imports at the top
+        args: ["--fix", "--ignore=E402"]
       - id: nbqa-black

autogen/agentchat/contrib/gpt_assistant_agent.py

@@ -21,6 +21,8 @@ class GPTAssistantAgent(ConversableAgent):
     This agent is unique in its reliance on the OpenAI Assistant for state management, differing from other agents like ConversableAgent.
     """
 
+    DEFAULT_MODEL_NAME = "gpt-4-0125-preview"
+
     def __init__(
         self,
         name="GPT Assistant",
@@ -61,16 +63,17 @@ def __init__(
 
         if llm_config is False:
             raise ValueError("llm_config=False is not supported for GPTAssistantAgent.")
-
-        # Use AutoGen OpenAIWrapper to create a client
-        model_name = "gpt-4-0125-preview"
+        # Use AutooGen OpenAIWrapper to create a client
         openai_client_cfg = copy.deepcopy(llm_config)
+        # Use the class variable
+        model_name = GPTAssistantAgent.DEFAULT_MODEL_NAME
+
         # GPTAssistantAgent's azure_deployment param may cause NotFoundError (404) in client.beta.assistants.list()
         # See: https://github.com/microsoft/autogen/pull/1721
         if openai_client_cfg.get("config_list") is not None and len(openai_client_cfg["config_list"]) > 0:
-            model_name = openai_client_cfg["config_list"][0].pop("model", "gpt-4-0125-preview")
+            model_name = openai_client_cfg["config_list"][0].pop("model", GPTAssistantAgent.DEFAULT_MODEL_NAME)
         else:
-            model_name = openai_client_cfg.pop("model", "gpt-4-0125-preview")
+            model_name = openai_client_cfg.pop("model", GPTAssistantAgent.DEFAULT_MODEL_NAME)
 
         logger.warning("OpenAI client config of GPTAssistantAgent(%s) - model: %s", name, model_name)
 

autogen/agentchat/conversable_agent.py

@@ -6,6 +6,7 @@
 import logging
 import re
 from collections import defaultdict
+from functools import partial
 from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union
 import warnings
 from openai import BadRequestError
@@ -325,6 +326,80 @@ def reply_func(
         if ignore_async_in_sync_chat and inspect.iscoroutinefunction(reply_func):
             self._ignore_async_func_in_sync_chat_list.append(reply_func)
 
+    @staticmethod
+    def _summary_from_nested_chats(
+        chat_queue: List[Dict[str, Any]], recipient: Agent, messages: Union[str, Callable], sender: Agent, config: Any
+    ) -> Tuple[bool, str]:
+        """A simple chat reply function.
+        This function initiate one or a sequence of chats between the "recipient" and the agents in the
+        chat_queue.
+
+        It extracts and returns a summary from the nested chat based on the "summary_method" in each chat in chat_queue.
+
+        Returns:
+            Tuple[bool, str]: A tuple where the first element indicates the completion of the chat, and the second element contains the summary of the last chat if any chats were initiated.
+        """
+        last_msg = messages[-1].get("content")
+        chat_to_run = []
+        for i, c in enumerate(chat_queue):
+            current_c = c.copy()
+            message = current_c.get("message")
+            # If message is not provided in chat_queue, we by default use the last message from the original chat history as the first message in this nested chat (for the first chat in the chat queue).
+            # NOTE: This setting is prone to change.
+            if message is None and i == 0:
+                message = last_msg
+            if callable(message):
+                message = message(recipient, messages, sender, config)
+            # We only run chat that has a valid message. NOTE: This is prone to change dependin on applications.
+            if message:
+                current_c["message"] = message
+                chat_to_run.append(current_c)
+        if not chat_to_run:
+            return True, None
+        res = recipient.initiate_chats(chat_to_run)
+        return True, res[-1].summary
+
+    def register_nested_chats(
+        self,
+        chat_queue: List[Dict[str, Any]],
+        trigger: Union[Type[Agent], str, Agent, Callable[[Agent], bool], List] = [Agent, None],
+        reply_func_from_nested_chats: Union[str, Callable] = "summary_from_nested_chats",
+        position: int = 2,
+        **kwargs,
+    ) -> None:
+        """Register a nested chat reply function.
+        Args:
+            chat_queue (list): a list of chat objects to be initiated.
+            trigger (Agent class, str, Agent instance, callable, or list): Default to [Agent, None]. Ref to `register_reply` for details.
+            reply_func_from_nested_chats (Callable, str): the reply function for the nested chat.
+                The function takes a chat_queue for nested chat, recipient agent, a list of messages, a sender agent and a config as input and returns a reply message.
+                Default to "summary_from_nested_chats", which corresponds to a built-in reply function that get summary from the nested chat_queue.
+            ```python
+            def reply_func_from_nested_chats(
+                chat_queue: List[Dict],
+                recipient: ConversableAgent,
+                messages: Optional[List[Dict]] = None,
+                sender: Optional[Agent] = None,
+                config: Optional[Any] = None,
+            ) -> Tuple[bool, Union[str, Dict, None]]:
+            ```
+            position (int): Ref to `register_reply` for details. Default to 2. It means we first check the termination and human reply, then check the registered nested chat reply.
+            kwargs: Ref to `register_reply` for details.
+        """
+        if reply_func_from_nested_chats == "summary_from_nested_chats":
+            reply_func_from_nested_chats = self._summary_from_nested_chats
+        if not callable(reply_func_from_nested_chats):
+            raise ValueError("reply_func_from_nested_chats must be a callable")
+        reply_func = partial(reply_func_from_nested_chats, chat_queue)
+        self.register_reply(
+            trigger,
+            reply_func,
+            position,
+            kwargs.get("config"),
+            kwargs.get("reset_config"),
+            ignore_async_in_sync_chat=kwargs.get("ignore_async_in_sync_chat"),
+        )
+
     @property
     def system_message(self) -> str:
         """Return the system message."""
@@ -477,7 +552,7 @@ def _process_message_before_send(
         """Process the message before sending it to the recipient."""
         hook_list = self.hook_lists["process_message_before_send"]
         for hook in hook_list:
-            message = hook(message, recipient, silent)
+            message = hook(sender=self, message=message, recipient=recipient, silent=silent)
         return message
 
     def send(
@@ -2054,15 +2129,18 @@ async def a_generate_init_message(self, **context) -> Union[str, Dict]:
         self._process_carryover(context)
         return context["message"]
 
-    def register_function(self, function_map: Dict[str, Callable]):
+    def register_function(self, function_map: Dict[str, Union[Callable, None]]):
         """Register functions to the agent.
 
         Args:
-            function_map: a dictionary mapping function names to functions.
+            function_map: a dictionary mapping function names to functions. if function_map[name] is None, the function will be removed from the function_map.
         """
-        for name in function_map.keys():
+        for name, func in function_map.items():
             self._assert_valid_name(name)
+            if func is None and name not in self._function_map.keys():
+                warnings.warn(f"The function {name} to remove doesn't exist", name)
         self._function_map.update(function_map)
+        self._function_map = {k: v for k, v in self._function_map.items() if v is not None}
 
     def update_function_signature(self, func_sig: Union[str, Dict], is_remove: None):
         """update a function_signature in the LLM configuration for function_call.

notebook/agentchat_custom_model.ipynb

@@ -5,7 +5,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<a href=\"https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+    "<a href=\"https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/agentchat_custom_model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
    ]
   },
   {