.Net: Fix issue 12775 (#12776)

### Motivation and Context

- Closes #12775 

### 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/OpenAIResponse/Step04_OpenAIResponseAgent_Tools.cs

@@ -28,7 +28,6 @@ public async Task InvokeAgentWithFunctionToolsAsync()
 
         // Create a plugin that defines the tools to be used by the agent.
         KernelPlugin plugin = KernelPluginFactory.CreateFromType<MenuPlugin>();
-        var tools = plugin.Select(f => f.ToToolDefinition(plugin.Name));
         agent.Kernel.Plugins.Add(plugin);
 
         ICollection<ChatMessageContent> messages =
@@ -127,4 +126,43 @@ public async Task InvokeAgentWithFileSearchAsync()
         this.FileClient.DeleteFile(file.Id, noThrowOptions);
         this.VectorStoreClient.DeleteVectorStore(createStoreOp.VectorStoreId, noThrowOptions);
     }
+
+    [Fact]
+    public async Task InvokeAgentWithMultipleToolsAsync()
+    {
+        // Define the agent
+        OpenAIResponseAgent agent = new(this.Client)
+        {
+            StoreEnabled = false,
+        };
+
+        // Create a plugin that defines the tools to be used by the agent.
+        KernelPlugin plugin = KernelPluginFactory.CreateFromType<MenuPlugin>();
+        agent.Kernel.Plugins.Add(plugin);
+
+        ICollection<ChatMessageContent> messages =
+        [
+            new ChatMessageContent(AuthorRole.User, "What is the special soup and its price?"),
+            new ChatMessageContent(AuthorRole.User, "What is the special drink and its price?"),
+        ];
+        foreach (ChatMessageContent message in messages)
+        {
+            WriteAgentChatMessage(message);
+        }
+
+        // ResponseCreationOptions allows you to specify tools for the agent.
+        ResponseCreationOptions creationOptions = new();
+        creationOptions.Tools.Add(ResponseTool.CreateWebSearchTool());
+        OpenAIResponseAgentInvokeOptions invokeOptions = new()
+        {
+            ResponseCreationOptions = creationOptions,
+        };
+
+        // Invoke the agent and output the response
+        var responseItems = agent.InvokeAsync(messages, options: invokeOptions);
+        await foreach (ChatMessageContent responseItem in responseItems)
+        {
+            WriteAgentChatMessage(responseItem);
+        }
+    }
 }

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

@@ -16,28 +16,47 @@ internal static ResponseCreationOptions CreateOptions(
         AgentThread agentThread,
         AgentInvokeOptions? invokeOptions)
     {
+        var instructions = $"{agent.Instructions}{(string.IsNullOrEmpty(agent.Instructions) || string.IsNullOrEmpty(invokeOptions?.AdditionalInstructions) ? "" : "\n")}{invokeOptions?.AdditionalInstructions}";
+        ResponseCreationOptions creationOptions;
         if (invokeOptions is OpenAIResponseAgentInvokeOptions responseAgentInvokeOptions &&
             responseAgentInvokeOptions.ResponseCreationOptions is not null)
         {
-            // Use the options provided by the caller
-            return responseAgentInvokeOptions.ResponseCreationOptions;
+            creationOptions = new ResponseCreationOptions
+            {
+                EndUserId = responseAgentInvokeOptions.ResponseCreationOptions.EndUserId ?? agent.GetDisplayName(),
+                Instructions = responseAgentInvokeOptions.ResponseCreationOptions.Instructions ?? instructions,
+                StoredOutputEnabled = responseAgentInvokeOptions.ResponseCreationOptions.StoredOutputEnabled ?? agent.StoreEnabled,
+                Background = responseAgentInvokeOptions.ResponseCreationOptions.Background,
+                ReasoningOptions = responseAgentInvokeOptions.ResponseCreationOptions.ReasoningOptions,
+                MaxOutputTokenCount = responseAgentInvokeOptions.ResponseCreationOptions.MaxOutputTokenCount,
+                TextOptions = responseAgentInvokeOptions.ResponseCreationOptions.TextOptions,
+                TruncationMode = responseAgentInvokeOptions.ResponseCreationOptions.TruncationMode,
+                ParallelToolCallsEnabled = responseAgentInvokeOptions.ResponseCreationOptions.ParallelToolCallsEnabled,
+                ToolChoice = responseAgentInvokeOptions.ResponseCreationOptions.ToolChoice,
+                Temperature = responseAgentInvokeOptions.ResponseCreationOptions.Temperature,
+                TopP = responseAgentInvokeOptions.ResponseCreationOptions.TopP,
+                PreviousResponseId = responseAgentInvokeOptions.ResponseCreationOptions.PreviousResponseId,
+            };
+            creationOptions.Tools.AddRange(responseAgentInvokeOptions.ResponseCreationOptions.Tools);
+            responseAgentInvokeOptions.ResponseCreationOptions.Metadata.ToList().ForEach(kvp => creationOptions.Metadata[kvp.Key] = kvp.Value);
         }
-
-        var responseTools = agent.GetKernel(invokeOptions).Plugins
-            .SelectMany(kp => kp.Select(kf => kf.ToResponseTool(kp.Name)));
-
-        var creationOptions = new ResponseCreationOptions
+        else
         {
-            EndUserId = agent.GetDisplayName(),
-            Instructions = $"{agent.Instructions}\n{invokeOptions?.AdditionalInstructions}",
-            StoredOutputEnabled = agent.StoreEnabled,
-        };
+            creationOptions = new ResponseCreationOptions
+            {
+                EndUserId = agent.GetDisplayName(),
+                Instructions = instructions,
+                StoredOutputEnabled = agent.StoreEnabled,
+            };
+        }
 
         if (agent.StoreEnabled && agentThread.Id is not null)
         {
             creationOptions.PreviousResponseId = agentThread.Id;
         }
 
+        var responseTools = agent.GetKernel(invokeOptions).Plugins
+            .SelectMany(kp => kp.Select(kf => kf.ToResponseTool(kp.Name)));
         if (responseTools is not null && responseTools.Any())
         {
             creationOptions.Tools.AddRange(responseTools);

dotnet/src/Agents/UnitTests/OpenAI/Internal/ResponseCreationOptionsFactoryTests.cs

@@ -0,0 +1,284 @@
+// Copyright (c) Microsoft. All rights reserved.
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Agents;
+using Microsoft.SemanticKernel.Agents.OpenAI;
+using Microsoft.SemanticKernel.Agents.OpenAI.Internal;
+using Moq;
+using OpenAI.Responses;
+using Xunit;
+
+namespace SemanticKernel.Agents.UnitTests.OpenAI.Internal;
+
+/// <summary>
+/// Unit testing of <see cref="ResponseCreationOptionsFactory"/>.
+/// </summary>
+public class ResponseCreationOptionsFactoryTests
+{
+    /// <summary>
+    /// Verify response options creation with null invoke options.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithNullInvokeOptionsTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", "You are a helpful assistant.", storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, null);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("Test Agent", options.EndUserId);
+        Assert.Equal("You are a helpful assistant.", options.Instructions);
+        Assert.False(options.StoredOutputEnabled);
+        Assert.Null(options.ReasoningOptions);
+        Assert.Null(options.MaxOutputTokenCount);
+        Assert.Null(options.TextOptions);
+        Assert.Null(options.TruncationMode);
+        Assert.Null(options.ParallelToolCallsEnabled);
+        Assert.Null(options.ToolChoice);
+        Assert.Empty(options.Tools);
+        Assert.Null(options.PreviousResponseId);
+    }
+
+    /// <summary>
+    /// Verify response options creation with store enabled and thread ID.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithStoreEnabledAndThreadIdTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", "You are a helpful assistant.", storeEnabled: true);
+        var mockThread = CreateMockAgentThread("thread-123");
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, null);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("Test Agent", options.EndUserId);
+        Assert.Equal("You are a helpful assistant.", options.Instructions);
+        Assert.True(options.StoredOutputEnabled);
+        Assert.Equal("thread-123", options.PreviousResponseId);
+    }
+
+    /// <summary>
+    /// Verify response options creation with additional instructions from invoke options.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithAdditionalInstructionsTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", "You are a helpful assistant.", storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+        var invokeOptions = new AgentInvokeOptions
+        {
+            AdditionalInstructions = "Be more concise."
+        };
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, invokeOptions);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("Test Agent", options.EndUserId);
+        Assert.Equal("You are a helpful assistant.\nBe more concise.", options.Instructions);
+        Assert.False(options.StoredOutputEnabled);
+    }
+
+    /// <summary>
+    /// Verify response options creation with OpenAIResponseAgentInvokeOptions with full ResponseCreationOptions.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithResponseAgentInvokeOptionsTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", "You are a helpful assistant.", storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+        var responseCreationOptions = new ResponseCreationOptions
+        {
+            EndUserId = "custom-user",
+            Instructions = "Custom instructions",
+            StoredOutputEnabled = true,
+            MaxOutputTokenCount = 1000,
+            ParallelToolCallsEnabled = true,
+            ToolChoice = ResponseToolChoice.CreateAutoChoice(),
+            Temperature = 0.7f,
+            TopP = 0.9f,
+            PreviousResponseId = "previous-response-id",
+        };
+        responseCreationOptions.Tools.Add(ResponseTool.CreateWebSearchTool());
+
+        var invokeOptions = new OpenAIResponseAgentInvokeOptions
+        {
+            AdditionalInstructions = "Additional instructions",
+            ResponseCreationOptions = responseCreationOptions
+        };
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, invokeOptions);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("custom-user", options.EndUserId);
+        Assert.Equal("Custom instructions", options.Instructions);
+        Assert.True(options.StoredOutputEnabled);
+        Assert.Equal(1000, options.MaxOutputTokenCount);
+        Assert.True(options.ParallelToolCallsEnabled);
+        Assert.NotNull(options.ToolChoice);
+        Assert.Single(options.Tools);
+        Assert.Equal(0.7f, options.Temperature);
+        Assert.Equal(0.9f, options.TopP);
+        Assert.Equal("previous-response-id", options.PreviousResponseId);
+    }
+
+    /// <summary>
+    /// Verify response options creation with ResponseCreationOptions having null values that fallback to agent defaults.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithResponseCreationOptionsNullFallbackTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", "You are a helpful assistant.", storeEnabled: true);
+        var mockThread = CreateMockAgentThread(null);
+        var responseCreationOptions = new ResponseCreationOptions
+        {
+            EndUserId = null, // Should fallback to agent display name
+            Instructions = null, // Should fallback to agent instructions + additional
+            StoredOutputEnabled = null // Should fallback to agent store enabled
+        };
+
+        var invokeOptions = new OpenAIResponseAgentInvokeOptions
+        {
+            AdditionalInstructions = "Be helpful",
+            ResponseCreationOptions = responseCreationOptions
+        };
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, invokeOptions);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("Test Agent", options.EndUserId);
+        Assert.Equal("You are a helpful assistant.\nBe helpful", options.Instructions);
+        Assert.True(options.StoredOutputEnabled);
+    }
+
+    /// <summary>
+    /// Verify response options creation when agent has null instructions.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithNullAgentInstructionsTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", null, storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+
+        var invokeOptions = new AgentInvokeOptions
+        {
+            AdditionalInstructions = "Be helpful"
+        };
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, invokeOptions);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("Be helpful", options.Instructions);
+    }
+
+    /// <summary>
+    /// Verify response options creation when both agent instructions and additional instructions are null.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithAllNullInstructionsTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", null, storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, null);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("", options.Instructions);
+    }
+
+    /// <summary>
+    /// Verify response options creation when agent store is disabled but thread ID exists.
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithStoreDisabledButThreadIdExistsTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("Test Agent", "You are a helpful assistant.", storeEnabled: false);
+        var mockThread = CreateMockAgentThread("thread-123");
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, null);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.False(options.StoredOutputEnabled);
+        Assert.Null(options.PreviousResponseId); // Should not set previous response ID when store is disabled
+    }
+
+    /// <summary>
+    /// Verify response options creation with empty agent name fallback to "UnnamedAgent".
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithEmptyAgentNameTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent("", "You are a helpful assistant.", storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, null);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("UnnamedAgent", options.EndUserId); // Empty name should fallback to "UnnamedAgent"
+    }
+
+    /// <summary>
+    /// Verify response options creation with null agent name fallback to "UnnamedAgent".
+    /// </summary>
+    [Fact]
+    public void CreateOptionsWithNullAgentNameTest()
+    {
+        // Arrange
+        var mockAgent = CreateMockAgent(null, "You are a helpful assistant.", storeEnabled: false);
+        var mockThread = CreateMockAgentThread(null);
+
+        // Act
+        var options = ResponseCreationOptionsFactory.CreateOptions(mockAgent, mockThread.Object, null);
+
+        // Assert
+        Assert.NotNull(options);
+        Assert.Equal("UnnamedAgent", options.EndUserId); // Null name should fallback to "UnnamedAgent"
+    }
+
+    private static OpenAIResponseAgent CreateMockAgent(string? name, string? instructions, bool storeEnabled)
+    {
+        var mockClient = new Mock<OpenAIResponseClient>();
+        var mockAgent = new OpenAIResponseAgent(mockClient.Object)
+        {
+            Name = name ?? "UnnamedAgent",
+            Instructions = instructions ?? string.Empty,
+            StoreEnabled = storeEnabled,
+            Kernel = new Kernel() // Empty kernel for testing
+        };
+
+        return mockAgent;
+    }
+
+    private static Mock<AgentThread> CreateMockAgentThread(string? threadId)
+    {
+        var mockThread = new Mock<AgentThread>();
+        mockThread.Setup(t => t.Id).Returns(threadId);
+        return mockThread;
+    }
+}