chore: import upstream snapshot with attribution

python/samples/concepts/agents/mixed_chat/mixed_chat_agents.py

@@ -0,0 +1,96 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+
+from azure.identity import AzureCliCredential
+
+from semantic_kernel.agents import AgentGroupChat, AzureAIAgent, AzureAIAgentSettings, ChatCompletionAgent
+from semantic_kernel.agents.strategies import TerminationStrategy
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
+from semantic_kernel.contents import AuthorRole
+
+"""
+The following sample demonstrates how to create a Azure AI Foundry Agent, 
+a chat completion agent and have them participate in a group chat to work towards
+the user's requirement.
+
+Note: This sample use the `AgentGroupChat` feature of Semantic Kernel, which is
+no longer maintained. For a replacement, consider using the `GroupChatOrchestration`.
+
+Read more about the `GroupChatOrchestration` here:
+https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python
+
+Here is a migration guide from `AgentGroupChat` to `GroupChatOrchestration`:
+https://learn.microsoft.com/semantic-kernel/support/migration/group-chat-orchestration-migration-guide?pivots=programming-language-python
+"""
+
+
+class ApprovalTerminationStrategy(TerminationStrategy):
+    """A strategy for determining when an agent should terminate."""
+
+    async def should_agent_terminate(self, agent, history):
+        """Check if the agent should terminate."""
+        return "approved" in history[-1].content.lower()
+
+
+REVIEWER_NAME = "ArtDirector"
+REVIEWER_INSTRUCTIONS = """
+You are an art director who has opinions about copywriting born of a love for David Ogilvy.
+The goal is to determine if the given copy is acceptable to print.
+If so, state that it is approved. Only include the word "approved" if it is so.
+If not, provide insight on how to refine suggested copy without example.
+"""
+
+COPYWRITER_NAME = "CopyWriter"
+COPYWRITER_INSTRUCTIONS = """
+You are a copywriter with ten years of experience and are known for brevity and a dry humor.
+The goal is to refine and decide on the single best copy as an expert in the field.
+Only provide a single proposal per response.
+You're laser focused on the goal at hand.
+Don't waste time with chit chat.
+Consider suggestions when refining an idea.
+"""
+
+
+async def main():
+    credential = AzureCliCredential()
+    async with (
+        # 1. Login to Azure and create a Azure AI Project Client
+        AzureAIAgent.create_client(credential=credential) as client,
+    ):
+        # 2. Create agents
+        agent_writer = AzureAIAgent(
+            client=client,
+            definition=await client.agents.create_agent(
+                model=AzureAIAgentSettings().model_deployment_name,
+                name=COPYWRITER_NAME,
+                instructions=COPYWRITER_INSTRUCTIONS,
+            ),
+        )
+        agent_reviewer = ChatCompletionAgent(
+            service=AzureChatCompletion(service_id="artdirector", credential=credential),
+            name=REVIEWER_NAME,
+            instructions=REVIEWER_INSTRUCTIONS,
+        )
+
+        # 3. Create the AgentGroupChat object and specify the list of agents along with the termination strategy
+        chat = AgentGroupChat(
+            agents=[agent_writer, agent_reviewer],
+            termination_strategy=ApprovalTerminationStrategy(agents=[agent_reviewer], maximum_iterations=10),
+        )
+
+        # 4. Provide the task an start running
+        input = "a slogan for a new line of electric cars."
+        await chat.add_chat_message(input)
+        print(f"# {AuthorRole.USER}: '{input}'")
+        async for content in chat.invoke():
+            print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
+
+        # 5. Done and remove the Auzre AI Foundry Agent.
+        print(f"# IS COMPLETE: {chat.is_complete}")
+
+        await client.agents.delete_agent(agent_writer.definition.id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/concepts/agents/mixed_chat/mixed_chat_agents_plugins.py

@@ -0,0 +1,133 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+from typing import Annotated
+
+from azure.core.credentials import TokenCredential
+from azure.identity import AzureCliCredential
+
+from semantic_kernel.agents import AgentGroupChat, AzureAssistantAgent, ChatCompletionAgent
+from semantic_kernel.agents.strategies import TerminationStrategy
+from semantic_kernel.connectors.ai import FunctionChoiceBehavior
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureOpenAISettings
+from semantic_kernel.contents import AuthorRole
+from semantic_kernel.functions import KernelArguments, kernel_function
+from semantic_kernel.kernel import Kernel
+
+"""
+The following sample demonstrates how to create an OpenAI
+assistant using either Azure OpenAI or OpenAI, a chat completion
+agent and have them participate in a group chat to work towards
+the user's requirement. The ChatCompletionAgent uses a plugin
+that is part of the agent group chat.
+
+Note: This sample use the `AgentGroupChat` feature of Semantic Kernel, which is
+no longer maintained. For a replacement, consider using the `GroupChatOrchestration`.
+
+Read more about the `GroupChatOrchestration` here:
+https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python
+
+Here is a migration guide from `AgentGroupChat` to `GroupChatOrchestration`:
+https://learn.microsoft.com/semantic-kernel/support/migration/group-chat-orchestration-migration-guide?pivots=programming-language-python
+"""
+
+
+class ApprovalTerminationStrategy(TerminationStrategy):
+    """A strategy for determining when an agent should terminate."""
+
+    async def should_agent_terminate(self, agent, history):
+        """Check if the agent should terminate."""
+        return "approved" in history[-1].content.lower()
+
+
+REVIEWER_NAME = "ArtDirector"
+REVIEWER_INSTRUCTIONS = """
+You are an art director who has opinions about copywriting born of a love for David Ogilvy.
+The goal is to determine if the given copy is acceptable to print.
+If so, state that it is approved. Only include the word "approved" if it is so.
+If not, provide insight on how to refine suggested copy without example.
+You should always tie the conversation back to the food specials offered by the plugin.
+"""
+
+COPYWRITER_NAME = "CopyWriter"
+COPYWRITER_INSTRUCTIONS = """
+You are a copywriter with ten years of experience and are known for brevity and a dry humor.
+The goal is to refine and decide on the single best copy as an expert in the field.
+Only provide a single proposal per response.
+You're laser focused on the goal at hand.
+Don't waste time with chit chat.
+Consider suggestions when refining an idea.
+"""
+
+
+class MenuPlugin:
+    """A sample Menu Plugin used for the concept sample."""
+
+    @kernel_function(description="Provides a list of specials from the menu.")
+    def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
+        return """
+        Special Soup: Clam Chowder
+        Special Salad: Cobb Salad
+        Special Drink: Chai Tea
+        """
+
+    @kernel_function(description="Provides the price of the requested menu item.")
+    def get_item_price(
+        self, menu_item: Annotated[str, "The name of the menu item."]
+    ) -> Annotated[str, "Returns the price of the menu item."]:
+        return "$9.99"
+
+
+def _create_kernel_with_chat_completion(service_id: str, credential: TokenCredential) -> Kernel:
+    kernel = Kernel()
+    kernel.add_service(AzureChatCompletion(service_id=service_id, credential=credential))
+    kernel.add_plugin(plugin=MenuPlugin(), plugin_name="menu")
+    return kernel
+
+
+async def main():
+    credential = AzureCliCredential()
+    kernel = _create_kernel_with_chat_completion("artdirector", credential)
+    settings = kernel.get_prompt_execution_settings_from_service_id(service_id="artdirector")
+    # Configure the function choice behavior to auto invoke kernel functions
+    settings.function_choice_behavior = FunctionChoiceBehavior.Auto()
+    agent_reviewer = ChatCompletionAgent(
+        kernel=kernel,
+        name=REVIEWER_NAME,
+        instructions=REVIEWER_INSTRUCTIONS,
+        arguments=KernelArguments(settings=settings),
+    )
+
+    # Create the Assistant Agent using Azure OpenAI resources
+    client = AzureAssistantAgent.create_client(credential=credential)
+
+    # Create the assistant definition
+    definition = await client.beta.assistants.create(
+        model=AzureOpenAISettings().chat_deployment_name,
+        name=COPYWRITER_NAME,
+        instructions=COPYWRITER_INSTRUCTIONS,
+    )
+
+    # Create the AzureAssistantAgent instance using the client and the assistant definition
+    agent_writer = AzureAssistantAgent(client=client, definition=definition)
+
+    chat = AgentGroupChat(
+        agents=[agent_writer, agent_reviewer],
+        termination_strategy=ApprovalTerminationStrategy(agents=[agent_reviewer], maximum_iterations=10),
+    )
+
+    input = "Write copy based on the food specials."
+    try:
+        await chat.add_chat_message(input)
+        print(f"# {AuthorRole.USER}: '{input}'")
+
+        async for content in chat.invoke():
+            print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
+
+        print(f"# IS COMPLETE: {chat.is_complete}")
+    finally:
+        await agent_writer.client.beta.assistants.delete(agent_writer.id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/concepts/agents/mixed_chat/mixed_chat_files.py

@@ -0,0 +1,117 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+import os
+
+from azure.core.credentials import TokenCredential
+from azure.identity import AzureCliCredential
+
+from semantic_kernel.agents import AgentGroupChat, AzureAssistantAgent, ChatCompletionAgent
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureOpenAISettings
+from semantic_kernel.contents import AnnotationContent, AuthorRole
+from semantic_kernel.kernel import Kernel
+
+"""
+The following sample demonstrates how to create an OpenAI
+assistant using either Azure OpenAI or OpenAI, a chat completion
+agent and have them participate in a group chat working on
+an uploaded file.
+
+Note: This sample use the `AgentGroupChat` feature of Semantic Kernel, which is
+no longer maintained. For a replacement, consider using the `GroupChatOrchestration`.
+
+Read more about the `GroupChatOrchestration` here:
+https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python
+
+Here is a migration guide from `AgentGroupChat` to `GroupChatOrchestration`:
+https://learn.microsoft.com/semantic-kernel/support/migration/group-chat-orchestration-migration-guide?pivots=programming-language-python
+"""
+
+
+def _create_kernel_with_chat_completion(service_id: str, credential: TokenCredential) -> Kernel:
+    kernel = Kernel()
+    kernel.add_service(AzureChatCompletion(service_id=service_id, credential=credential))
+    return kernel
+
+
+async def main():
+    credential = AzureCliCredential()
+    file_path = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))),
+        "resources",
+        "mixed_chat_files",
+        "user-context.txt",
+    )
+
+    # Create the client using Azure OpenAI resources and configuration
+    client = AzureAssistantAgent.create_client(credential=credential)
+
+    # If desired, create using OpenAI resources
+    # client = OpenAIAssistantAgent.create_client()
+
+    # Load the text file as a FileObject
+    with open(file_path, "rb") as file:
+        file = await client.files.create(file=file, purpose="assistants")
+
+    code_interpreter_tool, code_interpreter_tool_resource = AzureAssistantAgent.configure_code_interpreter_tool(
+        file_ids=file.id
+    )
+
+    definition = await client.beta.assistants.create(
+        model=AzureOpenAISettings().chat_deployment_name,
+        instructions="Create charts as requested without explanation.",
+        name="ChartMaker",
+        tools=code_interpreter_tool,
+        tool_resources=code_interpreter_tool_resource,
+    )
+
+    # Create the AzureAssistantAgent instance using the client and the assistant definition
+    analyst_agent = AzureAssistantAgent(client=client, definition=definition)
+
+    service_id = "summary"
+    summary_agent = ChatCompletionAgent(
+        kernel=_create_kernel_with_chat_completion(service_id=service_id, credential=credential),
+        instructions="Summarize the entire conversation for the user in natural language.",
+        name="SummaryAgent",
+    )
+
+    # Create the AgentGroupChat object, which will manage the chat between the agents
+    # We don't always need to specify the agents in the chat up front
+    # As shown below, calling `chat.invoke(agent=<agent>)` will automatically add the
+    # agent to the chat
+    chat = AgentGroupChat()
+
+    try:
+        user_and_agent_inputs = (
+            (
+                "Create a tab delimited file report of the ordered (descending) frequency distribution of "
+                "words in the file 'user-context.txt' for any words used more than once.",
+                analyst_agent,
+            ),
+            (None, summary_agent),
+        )
+
+        for input, agent in user_and_agent_inputs:
+            if input:
+                await chat.add_chat_message(input)
+                print(f"# {AuthorRole.USER}: '{input}'")
+
+            async for content in chat.invoke(agent=agent):
+                print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
+                if len(content.items) > 0:
+                    for item in content.items:
+                        if (
+                            isinstance(agent, AzureAssistantAgent)
+                            and isinstance(item, AnnotationContent)
+                            and item.file_id
+                        ):
+                            print(f"\n`{item.quote}` => {item.file_id}")
+                            response_content = await agent.client.files.content(item.file_id)
+                            print(response_content.text)
+    finally:
+        await client.files.delete(file_id=file.id)
+        await client.beta.assistants.delete(analyst_agent.id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/concepts/agents/mixed_chat/mixed_chat_images.py

@@ -0,0 +1,116 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+
+from azure.core.credentials import TokenCredential
+from azure.identity import AzureCliCredential
+
+from semantic_kernel.agents import AgentGroupChat, AzureAssistantAgent, ChatCompletionAgent
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureOpenAISettings
+from semantic_kernel.contents import AnnotationContent
+from semantic_kernel.contents.utils.author_role import AuthorRole
+from semantic_kernel.kernel import Kernel
+
+"""
+The following sample demonstrates how to create an OpenAI
+assistant using either Azure OpenAI or OpenAI, a chat completion
+agent and have them participate in a group chat working with
+image content.
+
+Note: This sample use the `AgentGroupChat` feature of Semantic Kernel, which is
+no longer maintained. For a replacement, consider using the `GroupChatOrchestration`.
+
+Read more about the `GroupChatOrchestration` here:
+https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python
+
+Here is a migration guide from `AgentGroupChat` to `GroupChatOrchestration`:
+https://learn.microsoft.com/semantic-kernel/support/migration/group-chat-orchestration-migration-guide?pivots=programming-language-python
+"""
+
+
+def _create_kernel_with_chat_completion(service_id: str, credential: TokenCredential) -> Kernel:
+    kernel = Kernel()
+    kernel.add_service(AzureChatCompletion(service_id=service_id, credential=credential))
+    return kernel
+
+
+async def main():
+    credential = AzureCliCredential()
+
+    # Create the client using Azure OpenAI resources and configuration
+    client = AzureAssistantAgent.create_client(credential=credential)
+
+    # Get the code interpreter tool and resources
+    code_interpreter_tool, code_interpreter_resources = AzureAssistantAgent.configure_code_interpreter_tool()
+
+    # Create the assistant definition
+    definition = await client.beta.assistants.create(
+        model=AzureOpenAISettings().chat_deployment_name,
+        name="Analyst",
+        instructions="Create charts as requested without explanation",
+        tools=code_interpreter_tool,
+        tool_resources=code_interpreter_resources,
+    )
+
+    # Create the AzureAssistantAgent instance using the client and the assistant definition
+    analyst_agent = AzureAssistantAgent(client=client, definition=definition)
+
+    service_id = "summary"
+    summary_agent = ChatCompletionAgent(
+        kernel=_create_kernel_with_chat_completion(service_id=service_id),
+        instructions="Summarize the entire conversation for the user in natural language.",
+        name="Summarizer",
+    )
+
+    # Create the AgentGroupChat object, which will manage the chat between the agents
+    # We don't always need to specify the agents in the chat up front
+    # As shown below, calling `chat.invoke(agent=<agent>)` will automatically add the
+    # agent to the chat
+    chat = AgentGroupChat()
+
+    try:
+        user_and_agent_inputs = (
+            (
+                """
+                Graph the percentage of storm events by state using a pie chart:
+
+                    State, StormCount
+                    TEXAS, 4701
+                    KANSAS, 3166
+                    IOWA, 2337
+                    ILLINOIS, 2022
+                    MISSOURI, 2016
+                    GEORGIA, 1983
+                    MINNESOTA, 1881
+                    WISCONSIN, 1850
+                    NEBRASKA, 1766
+                    NEW YORK, 1750
+                """.strip(),
+                analyst_agent,
+            ),
+            (None, summary_agent),
+        )
+
+        for input, agent in user_and_agent_inputs:
+            if input:
+                await chat.add_chat_message(input)
+                print(f"# {AuthorRole.USER}: '{input}'")
+
+            async for content in chat.invoke(agent=agent):
+                print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
+                if len(content.items) > 0:
+                    for item in content.items:
+                        if (
+                            isinstance(agent, AzureAssistantAgent)
+                            and isinstance(item, AnnotationContent)
+                            and item.file_id
+                        ):
+                            print(f"\n`{item.quote}` => {item.file_id}")
+                            response_content = await agent.client.files.content(item.file_id)
+                            print(response_content.text)
+    finally:
+        await client.beta.assistants.delete(analyst_agent.id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/concepts/agents/mixed_chat/mixed_chat_reset.py

@@ -0,0 +1,116 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from azure.core.credentials import TokenCredential
+from azure.identity import AzureCliCredential
+
+from semantic_kernel.agents import AgentGroupChat, AzureAssistantAgent, ChatCompletionAgent
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureOpenAISettings
+from semantic_kernel.contents import AuthorRole
+from semantic_kernel.kernel import Kernel
+
+if TYPE_CHECKING:
+    pass
+
+"""
+The following sample demonstrates how to create an OpenAI
+assistant using either Azure OpenAI or OpenAI, a chat completion
+agent and have them participate in a group chat to work towards
+the user's requirement. It also demonstrates how the underlying
+agent reset method is used to clear the current state of the chat
+
+Note: This sample use the `AgentGroupChat` feature of Semantic Kernel, which is
+no longer maintained. For a replacement, consider using the `GroupChatOrchestration`.
+
+Read more about the `GroupChatOrchestration` here:
+https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python
+
+Here is a migration guide from `AgentGroupChat` to `GroupChatOrchestration`:
+https://learn.microsoft.com/semantic-kernel/support/migration/group-chat-orchestration-migration-guide?pivots=programming-language-python
+"""
+
+
+def _create_kernel_with_chat_completion(service_id: str, credential: TokenCredential) -> Kernel:
+    kernel = Kernel()
+    kernel.add_service(AzureChatCompletion(service_id=service_id, credential=credential))
+    return kernel
+
+
+async def main():
+    credential = AzureCliCredential()
+
+    # First create the ChatCompletionAgent
+    chat_agent = ChatCompletionAgent(
+        kernel=_create_kernel_with_chat_completion("chat", credential),
+        name="chat_agent",
+        instructions="""
+            The user may either provide information or query on information previously provided. 
+            If the query does not correspond with information provided, inform the user that their query 
+            cannot be answered.
+            """,
+    )
+
+    # Next, we will create the AzureAssistantAgent
+
+    # Create the client using Azure OpenAI resources and configuration
+    client = AzureAssistantAgent.create_client(credential=credential)
+
+    # Create the assistant definition
+    definition = await client.beta.assistants.create(
+        model=AzureOpenAISettings().chat_deployment_name,
+        name="copywriter",
+        instructions="""
+            The user may either provide information or query on information previously provided. 
+            If the query does not correspond with information provided, inform the user that their query 
+            cannot be answered.
+            """,
+    )
+
+    # Create the AzureAssistantAgent instance using the client and the assistant definition
+    assistant_agent = AzureAssistantAgent(
+        client=client,
+        definition=definition,
+    )
+
+    # Create the AgentGroupChat object, which will manage the chat between the agents
+    # We don't always need to specify the agents in the chat up front
+    # As shown below, calling `chat.invoke(agent=<agent>)` will automatically add the
+    # agent to the chat
+    chat = AgentGroupChat()
+
+    try:
+        user_inputs = [
+            "What is my favorite color?",
+            "I like green.",
+            "What is my favorite color?",
+            "[RESET]",
+            "What is my favorite color?",
+        ]
+
+        for user_input in user_inputs:
+            # Check for reset indicator
+            if user_input == "[RESET]":
+                print("\nResetting chat...")
+                await chat.reset()
+                continue
+
+            # First agent (assistant_agent) receives the user input
+            await chat.add_chat_message(user_input)
+            print(f"\n{AuthorRole.USER}: '{user_input}'")
+            async for message in chat.invoke(agent=assistant_agent):
+                if message.content is not None:
+                    print(f"\n# {message.role} - {message.name or '*'}: '{message.content}'")
+
+            # Second agent (chat_agent) just responds without new user input
+            async for message in chat.invoke(agent=chat_agent):
+                if message.content is not None:
+                    print(f"\n# {message.role} - {message.name or '*'}: '{message.content}'")
+    finally:
+        await chat.reset()
+        await assistant_agent.client.beta.assistants.delete(assistant_agent.id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/concepts/agents/mixed_chat/mixed_chat_streaming.py

@@ -0,0 +1,112 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+
+from azure.core.credentials import TokenCredential
+from azure.identity import AzureCliCredential
+
+from semantic_kernel.agents import AgentGroupChat, AzureAssistantAgent, ChatCompletionAgent
+from semantic_kernel.agents.strategies import TerminationStrategy
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureOpenAISettings
+from semantic_kernel.contents import AuthorRole
+from semantic_kernel.kernel import Kernel
+
+"""
+The following sample demonstrates how to create an OpenAI
+assistant using either Azure OpenAI or OpenAI, a chat completion
+agent and have them participate in a group chat to work towards
+the user's requirement.
+
+Note: This sample use the `AgentGroupChat` feature of Semantic Kernel, which is
+no longer maintained. For a replacement, consider using the `GroupChatOrchestration`.
+
+Read more about the `GroupChatOrchestration` here:
+https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python
+
+Here is a migration guide from `AgentGroupChat` to `GroupChatOrchestration`:
+https://learn.microsoft.com/semantic-kernel/support/migration/group-chat-orchestration-migration-guide?pivots=programming-language-python
+"""
+
+
+class ApprovalTerminationStrategy(TerminationStrategy):
+    """A strategy for determining when an agent should terminate."""
+
+    async def should_agent_terminate(self, agent, history):
+        """Check if the agent should terminate."""
+        return "approved" in history[-1].content.lower()
+
+
+def _create_kernel_with_chat_completion(service_id: str, credential: TokenCredential) -> Kernel:
+    kernel = Kernel()
+    kernel.add_service(AzureChatCompletion(service_id=service_id, credential=credential))
+    return kernel
+
+
+async def main():
+    credential = AzureCliCredential()
+
+    # First create a ChatCompletionAgent
+    agent_reviewer = ChatCompletionAgent(
+        kernel=_create_kernel_with_chat_completion("artdirector", credential),
+        name="ArtDirector",
+        instructions="""
+            You are an art director who has opinions about copywriting born of a love for David Ogilvy.
+            The goal is to determine if the given copy is acceptable to print.
+            If so, state that it is approved. Only include the word "approved" if it is so.
+            If not, provide insight on how to refine suggested copy without example.
+            """,
+    )
+
+    # Next, we will create the AzureAssistantAgent
+
+    # Create the client using Azure OpenAI resources and configuration
+    client = AzureAssistantAgent.create_client(credential=credential)
+
+    # Create the assistant definition
+    definition = await client.beta.assistants.create(
+        model=AzureOpenAISettings().chat_deployment_name,
+        name="CopyWriter",
+        instructions="""
+        You are a copywriter with ten years of experience and are known for brevity and a dry humor.
+        The goal is to refine and decide on the single best copy as an expert in the field.
+        Only provide a single proposal per response.
+        You're laser focused on the goal at hand.
+        Don't waste time with chit chat.
+        Consider suggestions when refining an idea.
+        """,
+    )
+
+    # Create the AzureAssistantAgent instance using the client and the assistant definition
+    agent_writer = AzureAssistantAgent(
+        client=client,
+        definition=definition,
+    )
+
+    # Create the AgentGroupChat object, which will manage the chat between the agents
+    chat = AgentGroupChat(
+        agents=[agent_writer, agent_reviewer],
+        termination_strategy=ApprovalTerminationStrategy(agents=[agent_reviewer], maximum_iterations=10),
+    )
+
+    input = "a slogan for a new line of electric cars."
+
+    try:
+        await chat.add_chat_message(input)
+        print(f"# {AuthorRole.USER}: '{input}'")
+
+        last_agent = None
+        async for message in chat.invoke_stream():
+            if message.content is not None:
+                if last_agent != message.name:
+                    print(f"\n# {message.name}: ", end="", flush=True)
+                    last_agent = message.name
+                print(f"{message.content}", end="", flush=True)
+
+        print()
+        print(f"# IS COMPLETE: {chat.is_complete}")
+    finally:
+        await agent_writer.client.beta.assistants.delete(agent_writer.id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())