.Net: Avoid sending duplicate function tools when creating a thread (#10436)

### Motivation and Context

Same issue that was fixed here
#10413 but this time
the fix is for OpenAI Assistants.

### Description

<!-- Describe your changes, the overall approach, the underlying design.
These notes will help understanding how your code works. Thanks! -->

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [ ] The code builds clean without any errors or warnings
- [ ] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [ ] All unit tests pass, and I have added new tests where possible
- [ ] I didn't break anyone 😄

Author: markwallace-microsoft

dotnet/samples/GettingStartedWithAgents/AzureAIAgent/Step06_AzureAIAgent_Functions.cs

@@ -2,16 +2,16 @@
 using System.ComponentModel;
 using Azure.AI.Projects;
 using Microsoft.SemanticKernel;
-using Microsoft.SemanticKernel.Agents;
 using Microsoft.SemanticKernel.Agents.AzureAI;
 using Microsoft.SemanticKernel.ChatCompletion;
 using Agent = Azure.AI.Projects.Agent;
 
 namespace GettingStarted.AzureAgents;
 
 /// <summary>
-/// This example demonstrates similarity between using <see cref="AzureAIAgent"/>
-/// and <see cref="ChatCompletionAgent"/> (see: Step 2).
+/// This example demonstrates how to define function tools for an <see cref="AzureAIAgent"/>
+/// when the agent is created. This is useful if you want to retrieve the agent later and
+/// then dynamically check what function tools it requires.
 /// </summary>
 public class Step06_AzureAIAgent_Functions(ITestOutputHelper output) : BaseAgentsTest(output)
 {
@@ -37,12 +37,12 @@ public async Task UseSingleAgentWithFunctionToolsAsync()
             description: null,
             instructions: HostInstructions,
             tools: tools);
-        Microsoft.SemanticKernel.Agents.AzureAI.AzureAIAgent agent = new(definition, clientProvider)
+        AzureAIAgent agent = new(definition, clientProvider)
         {
             Kernel = new Kernel(),
         };
 
-        // Initialize plugin and add to the agent's Kernel (same as direct Kernel usage).
+        // Add plugin to the agent's Kernel (same as direct Kernel usage).
         agent.Kernel.Plugins.Add(plugin);
 
         // Create a thread for the agent conversation.

dotnet/samples/GettingStartedWithAgents/OpenAIAssistant/Step05_AssistantTool_Function.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.ComponentModel;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Agents.OpenAI;
+using Microsoft.SemanticKernel.ChatCompletion;
+using OpenAI.Assistants;
+
+namespace GettingStarted.OpenAIAssistants;
+
+/// <summary>
+/// This example demonstrates how to define function tools for an <see cref="OpenAIAssistantAgent"/>
+/// when the assistant is created. This is useful if you want to retrieve the assistant later and
+/// then dynamically check what function tools it requires.
+/// </summary>
+public class Step05_AssistantTool_Function(ITestOutputHelper output) : BaseAgentsTest(output)
+{
+    private const string HostName = "Host";
+    private const string HostInstructions = "Answer questions about the menu.";
+
+    [Fact]
+    public async Task UseSingleAssistantWithFunctionToolsAsync()
+    {
+        // Define the agent
+        OpenAIClientProvider provider = this.GetClientProvider();
+        var client = provider.Client.GetAssistantClient();
+        AssistantCreationOptions creationOptions =
+            new()
+            {
+                Name = HostName,
+                Instructions = HostInstructions,
+                Metadata = AssistantSampleMetadata,
+            };
+
+        // In this sample the function tools are added to the assistant this is
+        // important if you want to retrieve the assistant later and then dynamically check
+        // what function tools it requires.
+        KernelPlugin plugin = KernelPluginFactory.CreateFromType<MenuPlugin>();
+        plugin.Select(f => f.ToToolDefinition(plugin.Name)).ToList().ForEach(td => creationOptions.Tools.Add(td));
+
+        OpenAIAssistantAgent agent =
+            await OpenAIAssistantAgent.CreateAsync(
+                clientProvider: this.GetClientProvider(),
+                modelId: this.Model,
+                creationOptions: creationOptions,
+                kernel: new Kernel());
+
+        // Add plugin to the agent's Kernel (same as direct Kernel usage).
+        agent.Kernel.Plugins.Add(plugin);
+
+        // Create a thread for the agent conversation.
+        string threadId = await agent.CreateThreadAsync(new OpenAIThreadCreationOptions { Metadata = AssistantSampleMetadata });
+
+        // Respond to user input
+        try
+        {
+            await InvokeAgentAsync("Hello");
+            await InvokeAgentAsync("What is the special soup and its price?");
+            await InvokeAgentAsync("What is the special drink and its price?");
+            await InvokeAgentAsync("Thank you");
+        }
+        finally
+        {
+            await agent.DeleteThreadAsync(threadId);
+            await agent.DeleteAsync();
+        }
+
+        // Local function to invoke agent and display the conversation messages.
+        async Task InvokeAgentAsync(string input)
+        {
+            ChatMessageContent message = new(AuthorRole.User, input);
+            await agent.AddChatMessageAsync(threadId, message);
+            this.WriteAgentChatMessage(message);
+
+            await foreach (ChatMessageContent response in agent.InvokeAsync(threadId))
+            {
+                this.WriteAgentChatMessage(response);
+            }
+        }
+    }
+    private sealed class MenuPlugin
+    {
+        [KernelFunction, Description("Provides a list of specials from the menu.")]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1024:Use properties where appropriate", Justification = "Too smart")]
+        public string GetSpecials() =>
+            """
+            Special Soup: Clam Chowder
+            Special Salad: Cobb Salad
+            Special Drink: Chai Tea
+            """;
+
+        [KernelFunction, Description("Provides the price of the requested menu item.")]
+        public string GetItemPrice(
+            [Description("The name of the menu item.")]
+            string menuItem) =>
+            "$9.99";
+    }
+}

dotnet/src/Agents/OpenAI/Extensions/KernelFunctionExtensions.cs

@@ -4,7 +4,10 @@
 
 namespace Microsoft.SemanticKernel.Agents.OpenAI;
 
-internal static class KernelFunctionExtensions
+/// <summary>
+/// Extensions for <see cref="KernelFunction"/> to support OpenAI specific operations.
+/// </summary>
+public static class KernelFunctionExtensions
 {
     /// <summary>
     /// Convert <see cref="KernelFunction"/> to an OpenAI tool model.

dotnet/src/Agents/OpenAI/Internal/AssistantThreadActions.cs

@@ -165,7 +165,14 @@ public static async IAsyncEnumerable<ChatMessageContent> GetMessagesAsync(Assist
 
         logger.LogOpenAIAssistantCreatingRun(nameof(InvokeAsync), threadId);
 
-        ToolDefinition[]? tools = [.. agent.Tools, .. kernel.Plugins.SelectMany(p => p.Select(f => f.ToToolDefinition(p.Name)))];
+        List<ToolDefinition> tools = new(agent.Tools);
+
+        // Add unique functions from the Kernel which are not already present in the agent's tools
+        var functionToolNames = new HashSet<string>(tools.OfType<FunctionToolDefinition>().Select(t => t.FunctionName));
+        var functionTools = kernel.Plugins
+            .SelectMany(kp => kp.Select(kf => kf.ToToolDefinition(kp.Name)))
+            .Where(tool => !functionToolNames.Contains(tool.FunctionName));
+        tools.AddRange(functionTools);
 
         string? instructions = await agent.GetInstructionsAsync(kernel, arguments, cancellationToken).ConfigureAwait(false);
 

dotnet/src/Agents/OpenAI/OpenAIAssistantAgent.cs

@@ -59,7 +59,7 @@ public sealed class OpenAIAssistantAgent : KernelAgent
     internal IReadOnlyList<ToolDefinition> Tools => this._assistant.Tools;
 
     /// <summary>
-    /// Defines a new <see cref="OpenAIAssistantAgent"/>.
+    /// Create a new <see cref="OpenAIAssistantAgent"/>.
     /// </summary>
     /// <param name="clientProvider">The OpenAI client provider for accessing the API service.</param>
     /// <param name="capabilities">The assistant's capabilities.</param>
@@ -106,7 +106,7 @@ public async static Task<OpenAIAssistantAgent> CreateFromTemplateAsync(
     }
 
     /// <summary>
-    /// Defines a new <see cref="OpenAIAssistantAgent"/>.
+    /// Create a new <see cref="OpenAIAssistantAgent"/>.
     /// </summary>
     /// <param name="clientProvider">The OpenAI client provider for accessing the API service.</param>
     /// <param name="definition">The assistant definition.</param>
@@ -142,6 +142,44 @@ public static async Task<OpenAIAssistantAgent> CreateAsync(
             };
     }
 
+    /// <summary>
+    /// Create a new <see cref="OpenAIAssistantAgent"/>.
+    /// </summary>
+    /// <param name="clientProvider">OpenAI client provider for accessing the API service.</param>
+    /// <param name="modelId">OpenAI model id.</param>
+    /// <param name="creationOptions">The assistant creation options.</param>
+    /// <param name="kernel">The <see cref="Kernel"/> containing services, plugins, and other state for use throughout the operation.</param>
+    /// <param name="defaultArguments">Optional default arguments, including any <see cref="PromptExecutionSettings"/>.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>An <see cref="OpenAIAssistantAgent"/> instance</returns>
+    public static async Task<OpenAIAssistantAgent> CreateAsync(
+        OpenAIClientProvider clientProvider,
+        string modelId,
+        AssistantCreationOptions creationOptions,
+        Kernel kernel,
+        KernelArguments? defaultArguments = null,
+        CancellationToken cancellationToken = default)
+    {
+        // Validate input
+        Verify.NotNull(kernel, nameof(kernel));
+        Verify.NotNull(clientProvider, nameof(clientProvider));
+        Verify.NotNull(creationOptions, nameof(creationOptions));
+
+        // Create the client
+        AssistantClient client = CreateClient(clientProvider);
+
+        // Create the assistant
+        Assistant model = await client.CreateAssistantAsync(modelId, creationOptions, cancellationToken).ConfigureAwait(false);
+
+        // Instantiate the agent
+        return
+            new OpenAIAssistantAgent(model, clientProvider, client)
+            {
+                Kernel = kernel,
+                Arguments = defaultArguments
+            };
+    }
+
     /// <summary>
     /// Retrieves a list of assistant <see cref="OpenAIAssistantDefinition">definitions</see>.
     /// </summary>

dotnet/src/Agents/UnitTests/OpenAI/OpenAIAssistantAgentTests.cs

@@ -20,6 +20,7 @@ namespace SemanticKernel.Agents.UnitTests.OpenAI;
 /// <summary>
 /// Unit testing of <see cref="OpenAIAssistantAgent"/>.
 /// </summary>
+#pragma warning disable CS0419 // Ambiguous reference in cref attribute
 public sealed class OpenAIAssistantAgentTests : IDisposable
 {
     private readonly HttpMessageHandlerStub _messageHandlerStub;
@@ -906,3 +907,5 @@ public void MyFunction(int index)
         { }
     }
 }
+#pragma warning restore CS0419 // Ambiguous reference in cref attribute
+