Repo sync for protected branch

semantic-kernel/Frameworks/agent/TOC.yml

@@ -6,6 +6,8 @@
   href: chat-completion-agent.md
 - name: OpenAI Assistant Agent
   href: assistant-agent.md
+- name: Azure AI Agent
+  href: azure-ai-agent.md
 - name: Agent Collaboration
   href: agent-chat.md
 - name: Create an Agent from a Template

semantic-kernel/Frameworks/agent/agent-templates.md

@@ -76,10 +76,8 @@ ChatCompletionAgent agent =
 
 ::: zone pivot="programming-language-python"
 ```python
-kernel = Kernel()
-
 agent = ChatCompletionAgent(
-    kernel=kernel,
+    service=AzureChatCompletion(), # or other supported AI Services
     name="StoryTeller",
     instructions="Tell a story about {{$topic}} that is {{$length}} sentences long.",
     arguments=KernelArguments(topic="Dog", length="2"),
@@ -100,24 +98,34 @@ Templated instructions are especially powerful when working with an [`OpenAIAssi
 ::: zone pivot="programming-language-csharp"
 ```csharp
 // Retrieve an existing assistant definition by identifier
-OpenAIAssistantAgent agent = 
-    await OpenAIAssistantAgent.RetrieveAsync(
-        this.GetClientProvider(),
-        "<stored agent-identifier>",
-        new Kernel(),
-        new KernelArguments()
-        {
-            { "topic", "Dog" },
-            { "length", "3" },
-        });
+AzureOpenAIClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(new AzureCliCredential(), new Uri("<your endpoint>"));
+AssistantClient assistantClient = client.GetAssistantClient();
+Assistant assistant = await client.GetAssistantAsync();
+OpenAIAssistantAgent agent = new(assistant, assistantClient, new KernelPromptTemplateFactory(), PromptTemplateConfig.SemanticKernelTemplateFormat)
+{
+    Arguments = new KernelArguments()
+    {
+        { "topic", "Dog" },
+        { "length", "3" },
+    }
+}
 ```
 ::: zone-end
 
 ::: zone pivot="programming-language-python"
 ```python
-agent = await OpenAIAssistantAgent.retrieve(
-    id=<assistant_id>,
-    kernel=Kernel(),
+# Create the client using Azure OpenAI resources and configuration
+client, model = AzureAssistantAgent.setup_resources()
+
+# Retrieve the assistant definition from the server based on the assistant ID
+definition = await client.beta.assistants.retrieve(
+    assistant_id="your-assistant-id",
+)
+
+# Create the AzureAssistantAgent instance using the client and the assistant definition
+agent = AzureAssistantAgent(
+    client=client,
+    definition=definition,
     arguments=KernelArguments(topic="Dog", length="3"),
 )
 ```
@@ -130,10 +138,9 @@ agent = await OpenAIAssistantAgent.retrieve(
 ::: zone-end
 
 
-## Agent Definition from a _Prompt Template_
-
-The same _Prompt Template Config_ used to create a _Kernel Prompt Function_ can also be leveraged to define an agent. This allows for a unified approach in managing both prompts and agents, promoting consistency and reuse across different components. By externalizing agent definitions from the codebase, this method simplifies the management of multiple agents, making them easier to update and maintain without requiring changes to the underlying logic. This separation also enhances flexibility, enabling developers to modify agent behavior or introduce new agents by simply updating the configuration, rather than adjusting the code itself.
+## Agent Definition from a Prompt Template
 
+The same Prompt Template Config used to create a Kernel Prompt Function can also be leveraged to define an agent. This allows for a unified approach in managing both prompts and agents, promoting consistency and reuse across different components. By externalizing agent definitions from the codebase, this method simplifies the management of multiple agents, making them easier to update and maintain without requiring changes to the underlying logic. This separation also enhances flexibility, enabling developers to modify agent behavior or introduce new agents by simply updating the configuration, rather than adjusting the code itself.
 #### YAML Template
 
 ```yaml
@@ -192,7 +199,7 @@ data = yaml.safe_load(generate_story_yaml)
 prompt_template_config = PromptTemplateConfig(**data)
 
 agent = ChatCompletionAgent(
-    kernel=_create_kernel_with_chat_completion(),
+    service=AzureChatCompletion(), # or other supported AI services
     prompt_template_config=prompt_template_config,
     arguments=KernelArguments(topic="Dog", length="3"),
 )
@@ -249,10 +256,8 @@ await foreach (ChatMessageContent response in agent.InvokeAsync(chat, overrideAr
 ::: zone pivot="programming-language-python"
 
 ```python
-kernel = Kernel()
-
 agent = ChatCompletionAgent(
-    kernel=kernel,
+    service=AzureChatCompletion(),
     name="StoryTeller",
     instructions="Tell a story about {{$topic}} that is {{$length}} sentences long.",
     arguments=KernelArguments(topic="Dog", length="2"),

semantic-kernel/Frameworks/agent/assistant-agent.md

@@ -8,7 +8,7 @@ ms.author: crickman
 ms.date: 09/13/2024
 ms.service: semantic-kernel
 ---
-# Exploring the _Semantic Kernel_ `OpenAIAssistantAgent`
+# Exploring the Semantic Kernel `OpenAIAssistantAgent`
 
 > [!IMPORTANT]
 > This feature is in the release candidate stage. Features at this stage are nearly complete and generally stable, though they may undergo minor refinements or optimizations before reaching full general availability.
@@ -17,8 +17,6 @@ Detailed API documentation related to this discussion is available at:
 
 ::: zone pivot="programming-language-csharp"
 - [`OpenAIAssistantAgent`](/dotnet/api/microsoft.semantickernel.agents.openai.openaiassistantagent)
-- [`OpenAIAssistantDefinition`](/dotnet/api/microsoft.semantickernel.agents.openai.openaiassistantdefinition)
-- [`OpenAIClientProvider`](/dotnet/api/microsoft.semantickernel.agents.openai.openaiclientprovider)
 
 ::: zone-end
 
@@ -45,21 +43,55 @@ The _OpenAI Assistant API_ is a specialized interface designed for more advanced
 - [Assistant API in Azure](/azure/ai-services/openai/assistants-quickstart)
 
 
+## Preparing Your Development Environment
+
+To proceed with developing an `OpenAIAIAssistantAgent`, configure your development environment with the appropriate packages.
+
+::: zone pivot="programming-language-csharp"
+
+Add the `Microsoft.SemanticKernel.Agents.OpenAI` package to your project:
+
+```pwsh
+dotnet add package Microsoft.SemanticKernel.Agents.AzureAI --prerelease
+```
+
+You may also want to include the `Azure.Identity` package:
+
+```pwsh
+dotnet add package Azure.Identity
+```
+::: zone-end
+
+::: zone pivot="programming-language-python"
+
+Install the `semantic-kernel` package with the optional _Azure_ dependencies:
+
+```bash
+pip install semantic-kernel[azure]
+```
+
+::: zone-end
+
+::: zone pivot="programming-language-java"
+
+> Agents are currently unavailable in Java.
+
+::: zone-end
+
+
 ## Creating an `OpenAIAssistantAgent`
 
 Creating an `OpenAIAssistant` requires invoking a remote service, which is handled asynchronously. To manage this, the `OpenAIAssistantAgent` is instantiated through a static factory method, ensuring the process occurs in a non-blocking manner. This method abstracts the complexity of the asynchronous call, returning a promise or future once the assistant is fully initialized and ready for use.
 
 ::: zone pivot="programming-language-csharp"
 ```csharp
-OpenAIAssistantAgent agent =
-    await OpenAIAssistantAgent.CreateAsync(
-        OpenAIClientProvider.ForAzureOpenAI(/*<...service configuration>*/),
-        new OpenAIAssistantDefinition("<model name>")
-        {
-          Name = "<agent name>",
-          Instructions = "<agent instructions>",
-        },
-        new Kernel());
+AssistantClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(...).GetAssistantClient();
+Assistant assistant =
+    await this.AssistantClient.CreateAssistantAsync(
+        "<model name>",
+        "<agent name>",
+        instructions: "<agent instructions>");
+OpenAIAssistantAgent agent = new(assistant, client);
 ```
 ::: zone-end
 
@@ -119,11 +151,9 @@ Once created, the identifier of the assistant may be access via its identifier.
 For .NET, the agent identifier is exposed as a `string` via the  property defined by any agent.
 
 ```csharp
-OpenAIAssistantAgent agent =
-    await OpenAIAssistantAgent.RetrieveAsync(
-        OpenAIClientProvider.ForAzureOpenAI(/*<...service configuration>*/),
-        "<your agent id>",
-        new Kernel());
+AssistantClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(...).GetAssistantClient();
+Assistant assistant = await this.AssistantClient.GetAssistantAsync("<assistant id>");
+OpenAIAssistantAgent agent = new(assistant, client);
 ```
 ::: zone-end
 
@@ -220,20 +250,18 @@ await agent.delete_thread(thread_id)
 
 ## Deleting an `OpenAIAssistantAgent`
 
-Since the assistant's definition is stored remotely, it supports the capability to self-delete. This enables the agent to be removed from the system when it is no longer needed.
+Since the assistant's definition is stored remotely, it will persist if not deleted.  
+Deleting an assistant definition may be performed directly with the `AssistantClient`.
 
-> Note: Attempting to use an agent instance after being deleted results in an exception.
+> Note: Attempting to use an agent instance after being deleted will result in a service exception.
 
 ::: zone pivot="programming-language-csharp"
 
 For .NET, the agent identifier is exposed as a `string` via the [`Agent.Id`](/dotnet/api/microsoft.semantickernel.agents.agent.id) property defined by any agent.
 
 ```csharp
-// Perform the deletion
-await agent.DeleteAsync();
-
-// Inspect whether an agent has been deleted
-bool isDeleted = agent.IsDeleted();
+AssistantClient client = OpenAIAssistantAgent.CreateAzureOpenAIClient(...).GetAssistantClient();
+Assistant assistant = await this.AssistantClient.DeleteAssistantAsync("<assistant id>");
 ```
 ::: zone-end
 
@@ -261,5 +289,5 @@ For an end-to-end example for a `OpenAIAssistantAgent`, see:
 
 
 > [!div class="nextstepaction"]
-> [Agent Collaboration in `AgentChat`](./agent-chat.md)
+> [Exploring the Azure AI Agent](./azure-ai-agent.md)