.Net: SK integration with MEAI Abstractions

dotnet/SK-dotnet.sln

@@ -433,8 +433,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OllamaFunctionCalling", "sa
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenAIRealtime", "samples\Demos\OpenAIRealtime\OpenAIRealtime.csproj", "{6154129E-7A35-44A5-998E-B7001B5EDE14}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CreateChatGpt", "CreateChatGpt", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "VectorDataIntegrationTests", "VectorDataIntegrationTests", "{4F381919-F1BE-47D8-8558-3187ED04A84F}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QdrantIntegrationTests", "src\VectorDataIntegrationTests\QdrantIntegrationTests\QdrantIntegrationTests.csproj", "{27D33AB3-4DFF-48BC-8D76-FB2CDF90B707}"
@@ -1681,7 +1679,6 @@ Global
 		{B35B1DEB-04DF-4141-9163-01031B22C5D1} = {0D8C6358-5DAA-4EA6-A924-C268A9A21BC9}
 		{481A680F-476A-4627-83DE-2F56C484525E} = {5D4C0700-BBB5-418F-A7B2-F392B9A18263}
 		{6154129E-7A35-44A5-998E-B7001B5EDE14} = {5D4C0700-BBB5-418F-A7B2-F392B9A18263}
-		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {5D4C0700-BBB5-418F-A7B2-F392B9A18263}
 		{4F381919-F1BE-47D8-8558-3187ED04A84F} = {831DDCA2-7D2C-4C31-80DB-6BDB3E1F7AE0}
 		{27D33AB3-4DFF-48BC-8D76-FB2CDF90B707} = {4F381919-F1BE-47D8-8558-3187ED04A84F}
 		{B29A972F-A774-4140-AECF-6B577C476627} = {4F381919-F1BE-47D8-8558-3187ED04A84F}

dotnet/samples/Concepts/Agents/ChatCompletion_FunctionTermination.cs

@@ -13,15 +13,17 @@ namespace Agents;
 /// </summary>
 public class ChatCompletion_FunctionTermination(ITestOutputHelper output) : BaseAgentsTest(output)
 {
-    [Fact]
-    public async Task UseAutoFunctionInvocationFilterWithAgentInvocationAsync()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task UseAutoFunctionInvocationFilterWithAgentInvocation(bool useChatClient)
     {
         // Define the agent
         ChatCompletionAgent agent =
             new()
             {
                 Instructions = "Answer questions about the menu.",
-                Kernel = CreateKernelWithFilter(),
+                Kernel = CreateKernelWithFilter(useChatClient),
                 Arguments = new KernelArguments(new PromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }),
             };
 
@@ -53,15 +55,60 @@ async Task InvokeAgentAsync(string input)
         }
     }
 
-    [Fact]
-    public async Task UseAutoFunctionInvocationFilterWithStreamingAgentInvocationAsync()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task UseAutoFunctionInvocationFilterWithAgentChat(bool useChatClient)
     {
         // Define the agent
         ChatCompletionAgent agent =
             new()
             {
                 Instructions = "Answer questions about the menu.",
-                Kernel = CreateKernelWithFilter(),
+                Kernel = CreateKernelWithFilter(useChatClient),
+                Arguments = new KernelArguments(new PromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }),
+            };
+
+        KernelPlugin plugin = KernelPluginFactory.CreateFromType<MenuPlugin>();
+        agent.Kernel.Plugins.Add(plugin);
+
+        // Create a chat for agent interaction.
+        AgentGroupChat chat = new();
+
+        // Respond to user input, invoking functions where appropriate.
+        await InvokeAgentAsync("Hello");
+        await InvokeAgentAsync("What is the special soup?");
+        await InvokeAgentAsync("What is the special drink?");
+        await InvokeAgentAsync("Thank you");
+
+        // Display the entire chat history.
+        WriteChatHistory(await chat.GetChatMessagesAsync().ToArrayAsync());
+
+        // Local function to invoke agent and display the conversation messages.
+        async Task InvokeAgentAsync(string input)
+        {
+            ChatMessageContent message = new(AuthorRole.User, input);
+            chat.AddChatMessage(message);
+            this.WriteAgentChatMessage(message);
+
+            await foreach (ChatMessageContent response in chat.InvokeAsync(agent))
+            {
+                this.WriteAgentChatMessage(response);
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task UseAutoFunctionInvocationFilterWithStreamingAgentInvocation(bool useChatClient)
+    {
+        // Define the agent
+        ChatCompletionAgent agent =
+            new()
+            {
+                Instructions = "Answer questions about the menu.",
+                Kernel = CreateKernelWithFilter(useChatClient),
                 Arguments = new KernelArguments(new PromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }),
             };
 
@@ -115,6 +162,61 @@ async Task InvokeAgentAsync(string input)
         }
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task UseAutoFunctionInvocationFilterWithStreamingAgentChat(bool useChatClient)
+    {
+        // Define the agent
+        ChatCompletionAgent agent =
+            new()
+            {
+                Instructions = "Answer questions about the menu.",
+                Kernel = CreateKernelWithFilter(useChatClient),
+                Arguments = new KernelArguments(new PromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }),
+            };
+
+        KernelPlugin plugin = KernelPluginFactory.CreateFromType<MenuPlugin>();
+        agent.Kernel.Plugins.Add(plugin);
+
+        // Create a chat for agent interaction.
+        AgentGroupChat chat = new();
+
+        // Respond to user input, invoking functions where appropriate.
+        await InvokeAgentAsync("Hello");
+        await InvokeAgentAsync("What is the special soup?");
+        await InvokeAgentAsync("What is the special drink?");
+        await InvokeAgentAsync("Thank you");
+
+        // Display the entire chat history.
+        WriteChatHistory(await chat.GetChatMessagesAsync().ToArrayAsync());
+
+        // Local function to invoke agent and display the conversation messages.
+        async Task InvokeAgentAsync(string input)
+        {
+            ChatMessageContent message = new(AuthorRole.User, input);
+            chat.AddChatMessage(message);
+            this.WriteAgentChatMessage(message);
+
+            bool isFirst = false;
+            await foreach (StreamingChatMessageContent response in chat.InvokeStreamingAsync(agent))
+            {
+                if (string.IsNullOrEmpty(response.Content))
+                {
+                    continue;
+                }
+
+                if (!isFirst)
+                {
+                    Console.WriteLine($"\n# {response.Role} - {response.AuthorName ?? "*"}:");
+                    isFirst = true;
+                }
+
+                Console.WriteLine($"\t > streamed: '{response.Content}'");
+            }
+        }
+    }
+
     private void WriteChatHistory(IEnumerable<ChatMessageContent> chat)
     {
         Console.WriteLine("================================");
@@ -126,11 +228,18 @@ private void WriteChatHistory(IEnumerable<ChatMessageContent> chat)
         }
     }
 
-    private Kernel CreateKernelWithFilter()
+    private Kernel CreateKernelWithFilter(bool useChatClient)
     {
         IKernelBuilder builder = Kernel.CreateBuilder();
 
-        base.AddChatCompletionToKernel(builder);
+        if (useChatClient)
+        {
+            base.AddChatClientToKernel(builder);
+        }
+        else
+        {
+            base.AddChatCompletionToKernel(builder);
+        }
 
         builder.Services.AddSingleton<IAutoFunctionInvocationFilter>(new AutoInvocationFilter());
 

dotnet/samples/Concepts/Agents/ChatCompletion_HistoryReducer.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using Microsoft.Extensions.AI;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Agents;
 using Microsoft.SemanticKernel.ChatCompletion;
@@ -19,26 +20,34 @@ public class ChatCompletion_HistoryReducer(ITestOutputHelper output) : BaseTest(
     /// Demonstrate the use of <see cref="ChatHistoryTruncationReducer"/> when directly
     /// invoking a <see cref="ChatCompletionAgent"/>.
     /// </summary>
-    [Fact]
-    public async Task TruncatedAgentReductionAsync()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TruncatedAgentReduction(bool useChatClient)
     {
         // Define the agent
-        ChatCompletionAgent agent = CreateTruncatingAgent(10, 10);
+        ChatCompletionAgent agent = CreateTruncatingAgent(10, 10, useChatClient, out var chatClient);
 
         await InvokeAgentAsync(agent, 50);
+
+        chatClient?.Dispose();
     }
 
     /// <summary>
     /// Demonstrate the use of <see cref="ChatHistorySummarizationReducer"/> when directly
     /// invoking a <see cref="ChatCompletionAgent"/>.
     /// </summary>
-    [Fact]
-    public async Task SummarizedAgentReductionAsync()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task SummarizedAgentReduction(bool useChatClient)
     {
         // Define the agent
-        ChatCompletionAgent agent = CreateSummarizingAgent(10, 10);
+        ChatCompletionAgent agent = CreateSummarizingAgent(10, 10, useChatClient, out var chatClient);
 
         await InvokeAgentAsync(agent, 50);
+
+        chatClient?.Dispose();
     }
 
     // Proceed with dialog by directly invoking the agent and explicitly managing the history.
@@ -79,25 +88,30 @@ private async Task InvokeAgentAsync(ChatCompletionAgent agent, int messageCount)
         }
     }
 
-    private ChatCompletionAgent CreateSummarizingAgent(int reducerMessageCount, int reducerThresholdCount)
+    private ChatCompletionAgent CreateSummarizingAgent(int reducerMessageCount, int reducerThresholdCount, bool useChatClient, out IChatClient? chatClient)
     {
-        Kernel kernel = this.CreateKernelWithChatCompletion();
+        Kernel kernel = this.CreateKernelWithChatCompletion(useChatClient, out chatClient);
+
+        var service = useChatClient
+            ? kernel.GetRequiredService<IChatClient>().AsChatCompletionService()
+            : kernel.GetRequiredService<IChatCompletionService>();
+
         return
             new()
             {
                 Name = TranslatorName,
                 Instructions = TranslatorInstructions,
                 Kernel = kernel,
-                HistoryReducer = new ChatHistorySummarizationReducer(kernel.GetRequiredService<IChatCompletionService>(), reducerMessageCount, reducerThresholdCount),
+                HistoryReducer = new ChatHistorySummarizationReducer(service, reducerMessageCount, reducerThresholdCount),
             };
     }
 
-    private ChatCompletionAgent CreateTruncatingAgent(int reducerMessageCount, int reducerThresholdCount) =>
+    private ChatCompletionAgent CreateTruncatingAgent(int reducerMessageCount, int reducerThresholdCount, bool useChatClient, out IChatClient? chatClient) =>
         new()
         {
             Name = TranslatorName,
             Instructions = TranslatorInstructions,
-            Kernel = this.CreateKernelWithChatCompletion(),
+            Kernel = this.CreateKernelWithChatCompletion(useChatClient, out chatClient),
             HistoryReducer = new ChatHistoryTruncationReducer(reducerMessageCount, reducerThresholdCount),
         };
 }

dotnet/samples/Concepts/Agents/ChatCompletion_Serialization.cs

@@ -13,16 +13,18 @@ public class ChatCompletion_Serialization(ITestOutputHelper output) : BaseAgents
     private const string HostName = "Host";
     private const string HostInstructions = "Answer questions about the menu.";
 
-    [Fact]
-    public async Task SerializeAndRestoreAgentGroupChatAsync()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task SerializeAndRestoreAgentGroupChat(bool useChatClient)
     {
         // Define the agent
         ChatCompletionAgent agent =
             new()
             {
                 Instructions = HostInstructions,
                 Name = HostName,
-                Kernel = this.CreateKernelWithChatCompletion(),
+                Kernel = this.CreateKernelWithChatCompletion(useChatClient, out var chatClient),
                 Arguments = new KernelArguments(new PromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() }),
             };
 
@@ -51,6 +53,8 @@ public async Task SerializeAndRestoreAgentGroupChatAsync()
             this.WriteAgentChatMessage(content);
         }
 
+        chatClient?.Dispose();
+
         // Local function to invoke agent and display the conversation messages.
         async Task InvokeAgentAsync(AgentGroupChat chat, string input)
         {