ag2 0.3.2b2__py3-none-any.whl → 0.4__py3-none-any.whl

autogen/agentchat/contrib/swarm_agent.py

@@ -0,0 +1,414 @@
+# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
+#
+# SPDX-License-Identifier: Apache-2.0
+import json
+from dataclasses import dataclass
+from enum import Enum
+from inspect import signature
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+
+from pydantic import BaseModel
+
+from autogen.function_utils import get_function_schema
+from autogen.oai import OpenAIWrapper
+
+from ..agent import Agent
+from ..chat import ChatResult
+from ..conversable_agent import ConversableAgent
+from ..groupchat import GroupChat, GroupChatManager
+from ..user_proxy_agent import UserProxyAgent
+
+# Parameter name for context variables
+# Use the value in functions and they will be substituted with the context variables:
+# e.g. def my_function(context_variables: Dict[str, Any], my_other_parameters: Any) -> Any:
+__CONTEXT_VARIABLES_PARAM_NAME__ = "context_variables"
+
+
+class AfterWorkOption(Enum):
+    TERMINATE = "TERMINATE"
+    REVERT_TO_USER = "REVERT_TO_USER"
+    STAY = "STAY"
+
+
+@dataclass
+class AFTER_WORK:
+    agent: Union[AfterWorkOption, "SwarmAgent", str, Callable]
+
+    def __post_init__(self):
+        if isinstance(self.agent, str):
+            self.agent = AfterWorkOption(self.agent.upper())
+
+
+@dataclass
+class ON_CONDITION:
+    agent: "SwarmAgent"
+    condition: str = ""
+
+
+def initiate_swarm_chat(
+    initial_agent: "SwarmAgent",
+    messages: Union[List[Dict[str, Any]], str],
+    agents: List["SwarmAgent"],
+    user_agent: Optional[UserProxyAgent] = None,
+    max_rounds: int = 20,
+    context_variables: Optional[Dict[str, Any]] = None,
+    after_work: Optional[Union[AFTER_WORK, Callable]] = AFTER_WORK(AfterWorkOption.TERMINATE),
+) -> Tuple[ChatResult, Dict[str, Any], "SwarmAgent"]:
+    """Initialize and run a swarm chat
+
+    Args:
+        initial_agent: The first receiving agent of the conversation.
+        messages: Initial message(s).
+        agents: List of swarm agents.
+        user_agent: Optional user proxy agent for falling back to.
+        max_rounds: Maximum number of conversation rounds.
+        context_variables: Starting context variables.
+        after_work: Method to handle conversation continuation when an agent doesn't select the next agent. If no agent is selected and no tool calls are output, we will use this method to determine the next agent.
+            Must be a AFTER_WORK instance (which is a dataclass accepting a SwarmAgent, AfterWorkOption, A str (of the AfterWorkOption)) or a callable.
+            AfterWorkOption:
+                - TERMINATE (Default): Terminate the conversation.
+                - REVERT_TO_USER : Revert to the user agent if a user agent is provided. If not provided, terminate the conversation.
+                - STAY : Stay with the last speaker.
+
+            Callable: A custom function that takes the current agent, messages, groupchat, and context_variables as arguments and returns the next agent. The function should return None to terminate.
+                ```python
+                def custom_afterwork_func(last_speaker: SwarmAgent, messages: List[Dict[str, Any]], groupchat: GroupChat, context_variables: Optional[Dict[str, Any]]) -> Optional[SwarmAgent]:
+                ```
+    Returns:
+        ChatResult:     Conversations chat history.
+        Dict[str, Any]: Updated Context variables.
+        SwarmAgent:     Last speaker.
+    """
+    assert isinstance(initial_agent, SwarmAgent), "initial_agent must be a SwarmAgent"
+    assert all(isinstance(agent, SwarmAgent) for agent in agents), "agents must be a list of SwarmAgents"
+
+    context_variables = context_variables or {}
+    if isinstance(messages, str):
+        messages = [{"role": "user", "content": messages}]
+
+    swarm_agent_names = [agent.name for agent in agents]
+
+    tool_execution = SwarmAgent(
+        name="Tool_Execution",
+        system_message="Tool Execution",
+    )
+    tool_execution._set_to_tool_execution(context_variables=context_variables)
+
+    # Update tool execution agent with all the functions from all the agents
+    for agent in agents:
+        tool_execution._function_map.update(agent._function_map)
+
+    INIT_AGENT_USED = False
+
+    def swarm_transition(last_speaker: SwarmAgent, groupchat: GroupChat):
+        """Swarm transition function to determine the next agent in the conversation"""
+        nonlocal INIT_AGENT_USED
+        if not INIT_AGENT_USED:
+            INIT_AGENT_USED = True
+            return initial_agent
+
+        if "tool_calls" in groupchat.messages[-1]:
+            return tool_execution
+        if tool_execution._next_agent is not None:
+            next_agent = tool_execution._next_agent
+            tool_execution._next_agent = None
+            return next_agent
+
+        # get the last swarm agent
+        last_swarm_speaker = None
+        for message in reversed(groupchat.messages):
+            if "name" in message and message["name"] in swarm_agent_names:
+                agent = groupchat.agent_by_name(name=message["name"])
+                if isinstance(agent, SwarmAgent):
+                    last_swarm_speaker = agent
+                    break
+        if last_swarm_speaker is None:
+            raise ValueError("No swarm agent found in the message history")
+
+        # If the user last spoke, return to the agent prior
+        if (user_agent and last_speaker == user_agent) or groupchat.messages[-1]["role"] == "tool":
+            return last_swarm_speaker
+
+        # No agent selected via hand-offs (tool calls)
+        # Assume the work is Done
+        # override if agent-level after_work is defined, else use the global after_work
+        tmp_after_work = last_swarm_speaker.after_work if last_swarm_speaker.after_work is not None else after_work
+        if isinstance(tmp_after_work, AFTER_WORK):
+            tmp_after_work = tmp_after_work.agent
+
+        if isinstance(tmp_after_work, SwarmAgent):
+            return tmp_after_work
+        elif isinstance(tmp_after_work, AfterWorkOption):
+            if tmp_after_work == AfterWorkOption.TERMINATE or (
+                user_agent is None and tmp_after_work == AfterWorkOption.REVERT_TO_USER
+            ):
+                return None
+            elif tmp_after_work == AfterWorkOption.REVERT_TO_USER:
+                return user_agent
+            elif tmp_after_work == AfterWorkOption.STAY:
+                return last_speaker
+        elif isinstance(tmp_after_work, Callable):
+            return tmp_after_work(last_speaker, groupchat.messages, groupchat, context_variables)
+        else:
+            raise ValueError("Invalid After Work condition")
+
+    # If there's only one message and there's no identified swarm agent
+    # Start with a user proxy agent, creating one if they haven't passed one in
+    if len(messages) == 1 and "name" not in messages[0] and not user_agent:
+        temp_user_proxy = [UserProxyAgent(name="_User")]
+    else:
+        temp_user_proxy = []
+
+    groupchat = GroupChat(
+        agents=[tool_execution] + agents + ([user_agent] if user_agent is not None else temp_user_proxy),
+        messages=[],  # Set to empty. We will resume the conversation with the messages
+        max_round=max_rounds,
+        speaker_selection_method=swarm_transition,
+    )
+    manager = GroupChatManager(groupchat)
+    clear_history = True
+
+    if len(messages) > 1:
+        last_agent, last_message = manager.resume(messages=messages)
+        clear_history = False
+    else:
+        last_message = messages[0]
+
+        if "name" in last_message:
+            if "name" in swarm_agent_names:
+                # If there's a name in the message and it's a swarm agent, use that
+                last_agent = groupchat.agent_by_name(name=last_message["name"])
+            else:
+                raise ValueError(f"Invalid swarm agent name in last message: {last_message['name']}")
+        else:
+            # No name, so we're using the user proxy to start the conversation
+            if user_agent:
+                last_agent = user_agent
+            else:
+                # If no user agent passed in, use our temporary user proxy
+                last_agent = temp_user_proxy[0]
+
+    chat_result = last_agent.initiate_chat(
+        manager,
+        message=last_message,
+        clear_history=clear_history,
+    )
+
+    # Clear the temporary user proxy's name from messages
+    if len(temp_user_proxy) == 1:
+        for message in chat_result.chat_history:
+            if "name" in message and message["name"] == "_User":
+                # delete the name key from the message
+                del message["name"]
+
+    return chat_result, context_variables, manager.last_speaker
+
+
+class SwarmResult(BaseModel):
+    """
+    Encapsulates the possible return values for a swarm agent function.
+
+    Args:
+        values (str): The result values as a string.
+        agent (SwarmAgent): The swarm agent instance, if applicable.
+        context_variables (dict): A dictionary of context variables.
+    """
+
+    values: str = ""
+    agent: Optional["SwarmAgent"] = None
+    context_variables: Dict[str, Any] = {}
+
+    class Config:  # Add this inner class
+        arbitrary_types_allowed = True
+
+    def __str__(self):
+        return self.values
+
+
+class SwarmAgent(ConversableAgent):
+    """Swarm agent for participating in a swarm.
+
+    SwarmAgent is a subclass of ConversableAgent.
+
+    Additional args:
+        functions (List[Callable]): A list of functions to register with the agent.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        system_message: Optional[str] = "You are a helpful AI Assistant.",
+        llm_config: Optional[Union[Dict, Literal[False]]] = None,
+        functions: Union[List[Callable], Callable] = None,
+        is_termination_msg: Optional[Callable[[Dict], bool]] = None,
+        max_consecutive_auto_reply: Optional[int] = None,
+        human_input_mode: Literal["ALWAYS", "NEVER", "TERMINATE"] = "NEVER",
+        description: Optional[str] = None,
+        code_execution_config=False,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            name,
+            system_message,
+            is_termination_msg,
+            max_consecutive_auto_reply,
+            human_input_mode,
+            llm_config=llm_config,
+            description=description,
+            code_execution_config=code_execution_config,
+            **kwargs,
+        )
+
+        if isinstance(functions, list):
+            self.add_functions(functions)
+        elif isinstance(functions, Callable):
+            self.add_single_function(functions)
+
+        self.after_work = None
+
+        # use in the tool execution agent to transfer to the next agent
+        self._context_variables = {}
+        self._next_agent = None
+
+    def _set_to_tool_execution(self, context_variables: Optional[Dict[str, Any]] = None):
+        """Set to a special instance of SwarmAgent that is responsible for executing tool calls from other swarm agents.
+        This agent will be used internally and should not be visible to the user.
+
+        It will execute the tool calls and update the context_variables and next_agent accordingly.
+        """
+        self._next_agent = None
+        self._context_variables = context_variables or {}
+        self._reply_func_list.clear()
+        self.register_reply([Agent, None], SwarmAgent.generate_swarm_tool_reply)
+
+    def __str__(self):
+        return f"SwarmAgent --> {self.name}"
+
+    def register_hand_off(
+        self,
+        hand_to: Union[List[Union[ON_CONDITION, AFTER_WORK]], ON_CONDITION, AFTER_WORK],
+    ):
+        """Register a function to hand off to another agent.
+
+        Args:
+            hand_to: A list of ON_CONDITIONs and an, optional, AFTER_WORK condition
+
+        Hand off template:
+        def transfer_to_agent_name() -> SwarmAgent:
+            return agent_name
+        1. register the function with the agent
+        2. register the schema with the agent, description set to the condition
+        """
+        if isinstance(hand_to, (ON_CONDITION, AFTER_WORK)):
+            hand_to = [hand_to]
+
+        for transit in hand_to:
+            if isinstance(transit, AFTER_WORK):
+                self.after_work = transit
+            elif isinstance(transit, ON_CONDITION):
+
+                # Create closure with current loop transit value
+                # to ensure the condition matches the one in the loop
+                def make_transfer_function(current_transit):
+                    def transfer_to_agent() -> "SwarmAgent":
+                        return current_transit.agent
+
+                    return transfer_to_agent
+
+                transfer_func = make_transfer_function(transit)
+                self.add_single_function(transfer_func, f"transfer_to_{transit.agent.name}", transit.condition)
+            else:
+                raise ValueError("Invalid hand off condition, must be either ON_CONDITION or AFTER_WORK")
+
+    def generate_swarm_tool_reply(
+        self,
+        messages: Optional[List[Dict]] = None,
+        sender: Optional[Agent] = None,
+        config: Optional[OpenAIWrapper] = None,
+    ) -> Tuple[bool, dict]:
+        """Pre-processes and generates tool call replies.
+
+        This function:
+        1. Adds context_variables back to the tool call for the function, if necessary.
+        2. Generates the tool calls reply.
+        3. Updates context_variables and next_agent based on the tool call response."""
+
+        if config is None:
+            config = self
+        if messages is None:
+            messages = self._oai_messages[sender]
+
+        message = messages[-1]
+        if "tool_calls" in message:
+            # 1. add context_variables to the tool call arguments
+            for tool_call in message["tool_calls"]:
+                if tool_call["type"] == "function":
+                    function_name = tool_call["function"]["name"]
+
+                    # Check if this function exists in our function map
+                    if function_name in self._function_map:
+                        func = self._function_map[function_name]  # Get the original function
+
+                        # Check if function has context_variables parameter
+                        sig = signature(func)
+                        if __CONTEXT_VARIABLES_PARAM_NAME__ in sig.parameters:
+                            current_args = json.loads(tool_call["function"]["arguments"])
+                            current_args[__CONTEXT_VARIABLES_PARAM_NAME__] = self._context_variables
+                            # Update the tool call with new arguments
+                            tool_call["function"]["arguments"] = json.dumps(current_args)
+
+            # 2. generate tool calls reply
+            _, tool_message = self.generate_tool_calls_reply([message])
+
+            # 3. update context_variables and next_agent, convert content to string
+            for tool_response in tool_message["tool_responses"]:
+                content = tool_response.get("content")
+                if isinstance(content, SwarmResult):
+                    if content.context_variables != {}:
+                        self._context_variables.update(content.context_variables)
+                    if content.agent is not None:
+                        self._next_agent = content.agent
+                elif isinstance(content, Agent):
+                    self._next_agent = content
+                tool_response["content"] = str(tool_response["content"])
+
+            return True, tool_message
+        return False, None
+
+    def add_single_function(self, func: Callable, name=None, description=""):
+        if name:
+            func._name = name
+        else:
+            func._name = func.__name__
+
+        if description:
+            func._description = description
+        else:
+            # Use function's docstring, strip whitespace, fall back to empty string
+            func._description = (func.__doc__ or "").strip()
+
+        f = get_function_schema(func, name=func._name, description=func._description)
+
+        # Remove context_variables parameter from function schema
+        f_no_context = f.copy()
+        if __CONTEXT_VARIABLES_PARAM_NAME__ in f_no_context["function"]["parameters"]["properties"]:
+            del f_no_context["function"]["parameters"]["properties"][__CONTEXT_VARIABLES_PARAM_NAME__]
+        if "required" in f_no_context["function"]["parameters"]:
+            required = f_no_context["function"]["parameters"]["required"]
+            f_no_context["function"]["parameters"]["required"] = [
+                param for param in required if param != __CONTEXT_VARIABLES_PARAM_NAME__
+            ]
+            # If required list is empty, remove it
+            if not f_no_context["function"]["parameters"]["required"]:
+                del f_no_context["function"]["parameters"]["required"]
+
+        self.update_tool_signature(f_no_context, is_remove=False)
+        self.register_function({func._name: func})
+
+    def add_functions(self, func_list: List[Callable]):
+        for func in func_list:
+            self.add_single_function(func)
+
+
+# Forward references for SwarmAgent in SwarmResult
+SwarmResult.update_forward_refs()

autogen/agentchat/contrib/tool_retriever.py

@@ -0,0 +1,114 @@
+import importlib.util
+import inspect
+import os
+from textwrap import dedent, indent
+
+import pandas as pd
+from sentence_transformers import SentenceTransformer, util
+
+from autogen import AssistantAgent, UserProxyAgent
+from autogen.coding import LocalCommandLineCodeExecutor
+
+
+class ToolBuilder:
+    TOOL_USING_PROMPT = """# Functions
+    You have access to the following functions. They can be accessed from the module called 'functions' by their function names.
+For example, if there is a function called `foo` you could import it by writing `from functions import foo`
+{functions}
+"""
+
+    def __init__(self, corpus_path, retriever="all-mpnet-base-v2"):
+
+        self.df = pd.read_csv(corpus_path, sep="\t")
+        document_list = self.df["document_content"].tolist()
+
+        self.model = SentenceTransformer(retriever)
+        self.embeddings = self.model.encode(document_list)
+
+    def retrieve(self, query, top_k=3):
+        # Encode the query using the Sentence Transformer model
+        query_embedding = self.model.encode([query])
+
+        hits = util.semantic_search(query_embedding, self.embeddings, top_k=top_k)
+
+        results = []
+        for hit in hits[0]:
+            results.append(self.df.iloc[hit["corpus_id"], 1])
+        return results
+
+    def bind(self, agent: AssistantAgent, functions: str):
+        """Binds the function to the agent so that agent is aware of it."""
+        sys_message = agent.system_message
+        sys_message += self.TOOL_USING_PROMPT.format(functions=functions)
+        agent.update_system_message(sys_message)
+        return
+
+    def bind_user_proxy(self, agent: UserProxyAgent, tool_root: str):
+        """
+        Updates user proxy agent with a executor so that code executor can successfully execute function-related code.
+        Returns an updated user proxy.
+        """
+        # Find all the functions in the tool root
+        functions = find_callables(tool_root)
+
+        code_execution_config = agent._code_execution_config
+        executor = LocalCommandLineCodeExecutor(
+            timeout=code_execution_config.get("timeout", 180),
+            work_dir=code_execution_config.get("work_dir", "coding"),
+            functions=functions,
+        )
+        code_execution_config = {
+            "executor": executor,
+            "last_n_messages": code_execution_config.get("last_n_messages", 1),
+        }
+        updated_user_proxy = UserProxyAgent(
+            name=agent.name,
+            is_termination_msg=agent._is_termination_msg,
+            code_execution_config=code_execution_config,
+            human_input_mode="NEVER",
+            default_auto_reply=agent._default_auto_reply,
+        )
+        return updated_user_proxy
+
+
+def get_full_tool_description(py_file):
+    """
+    Retrieves the function signature for a given Python file.
+    """
+    with open(py_file, "r") as f:
+        code = f.read()
+        exec(code)
+        function_name = os.path.splitext(os.path.basename(py_file))[0]
+        if function_name in locals():
+            func = locals()[function_name]
+            content = f"def {func.__name__}{inspect.signature(func)}:\n"
+            docstring = func.__doc__
+
+            if docstring:
+                docstring = dedent(docstring)
+                docstring = '"""' + docstring + '"""'
+                docstring = indent(docstring, "    ")
+                content += docstring + "\n"
+            return content
+        else:
+            raise ValueError(f"Function {function_name} not found in {py_file}")
+
+
+def find_callables(directory):
+    """
+    Find all callable objects defined in Python files within the specified directory.
+    """
+    callables = []
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".py"):
+                module_name = os.path.splitext(file)[0]
+                module_path = os.path.join(root, file)
+                spec = importlib.util.spec_from_file_location(module_name, module_path)
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                for name, value in module.__dict__.items():
+                    if callable(value) and name == module_name:
+                        callables.append(value)
+                        break
+    return callables

autogen/agentchat/conversable_agent.py

@@ -164,7 +164,7 @@ class ConversableAgent(LLMAgent):
             except TypeError as e:
                 raise TypeError(
                     "Please implement __deepcopy__ method for each value class in llm_config to support deepcopy."
-                    " Refer to the docs for more details: https://ag2ai.github.io/autogen/docs/topics/llm_configuration#adding-http-client-in-llm_config-for-proxy"
+                    " Refer to the docs for more details: https://ag2ai.github.io/ag2/docs/topics/llm_configuration#adding-http-client-in-llm_config-for-proxy"
                 ) from e
 
         self._validate_llm_config(llm_config)
@@ -659,6 +659,9 @@ class ConversableAgent(LLMAgent):
 
         if message.get("role") in ["function", "tool"]:
             oai_message["role"] = message.get("role")
+            if "tool_responses" in oai_message:
+                for tool_response in oai_message["tool_responses"]:
+                    tool_response["content"] = str(tool_response["content"])
         elif "override_role" in message:
             # If we have a direction to override the role then set the
             # role accordingly. Used to customise the role for the
@@ -791,15 +794,16 @@ class ConversableAgent(LLMAgent):
                 "Message can't be converted into a valid ChatCompletion message. Either content or function_call must be provided."
             )
 
-    def _print_received_message(self, message: Union[Dict, str], sender: Agent):
+    def _print_received_message(self, message: Union[Dict, str], sender: Agent, skip_head: bool = False):
         iostream = IOStream.get_default()
         # print the message received
-        iostream.print(colored(sender.name, "yellow"), "(to", f"{self.name}):\n", flush=True)
+        if not skip_head:
+            iostream.print(colored(sender.name, "yellow"), "(to", f"{self.name}):\n", flush=True)
         message = self._message_to_dict(message)
 
         if message.get("tool_responses"):  # Handle tool multi-call responses
             for tool_response in message["tool_responses"]:
-                self._print_received_message(tool_response, sender)
+                self._print_received_message(tool_response, sender, skip_head=True)
             if message.get("role") == "tool":
                 return  # If role is tool, then content is just a concatenation of all tool_responses
 
@@ -2288,7 +2292,7 @@ class ConversableAgent(LLMAgent):
             result.append(char)
         return "".join(result)
 
-    def execute_function(self, func_call, verbose: bool = False) -> Tuple[bool, Dict[str, str]]:
+    def execute_function(self, func_call, verbose: bool = False) -> Tuple[bool, Dict[str, Any]]:
         """Execute a function call and return the result.
 
         Override this function to modify the way to execute function and tool calls.
@@ -2342,7 +2346,7 @@ class ConversableAgent(LLMAgent):
         return is_exec_success, {
             "name": func_name,
             "role": "function",
-            "content": str(content),
+            "content": content,
         }
 
     async def a_execute_function(self, func_call):
@@ -2397,7 +2401,7 @@ class ConversableAgent(LLMAgent):
         return is_exec_success, {
             "name": func_name,
             "role": "function",
-            "content": str(content),
+            "content": content,
         }
 
     def generate_init_message(self, message: Union[Dict, str, None], **kwargs) -> Union[str, Dict]:

autogen/agentchat/groupchat.py

@@ -294,6 +294,8 @@ class GroupChat:
         # if the role is tool, it is OK to modify the name
         if message["role"] != "function":
             message["name"] = speaker.name
+        if not isinstance(message["content"], str) and not isinstance(message["content"], list):
+            message["content"] = str(message["content"])
         message["content"] = content_str(message["content"])
         self.messages.append(message)
 

autogen/oai/completion.py

@@ -742,7 +742,7 @@ class Completion(openai_Completion):
                 E.g., `prompt="Complete the following sentence: {prefix}, context={"prefix": "Today I feel"}`.
                 The actual prompt will be:
                 "Complete the following sentence: Today I feel".
-                More examples can be found at [templating](https://ag2ai.github.io/autogen/docs/Use-Cases/enhanced_inference#templating).
+                More examples can be found at [templating](https://ag2ai.github.io/ag2/docs/Use-Cases/enhanced_inference#templating).
             use_cache (bool, Optional): Whether to use cached responses.
             config_list (List, Optional): List of configurations for the completion to try.
                 The first one that does not raise an error will be used.
@@ -804,7 +804,7 @@ class Completion(openai_Completion):
         logger.warning(
             "Completion.create is deprecated in autogen, pyautogen v0.2 and openai>=1. "
             "The new openai requires initiating a client for inference. "
-            "Please refer to https://ag2ai.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification"
+            "Please refer to https://ag2ai.github.io/ag2/docs/Use-Cases/enhanced_inference#api-unification"
         )
         if ERROR:
             raise ERROR

autogen/oai/gemini.py

@@ -171,7 +171,7 @@ class GeminiClient:
             raise ValueError(
                 "Please provide a model name for the Gemini Client. "
                 "You can configure it in the OAI Config List file. "
-                "See this [LLM configuration tutorial](https://ag2ai.github.io/autogen/docs/topics/llm_configuration/) for more details."
+                "See this [LLM configuration tutorial](https://ag2ai.github.io/ag2/docs/topics/llm_configuration/) for more details."
             )
 
         params.get("api_type", "google")  # not used

autogen/version.py

@@ -4,4 +4,4 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-__version__ = "0.3.2b2"
+__version__ = "0.4"