From 6cd056cc901fa3984402a5607c20c02f0a24d40f Mon Sep 17 00:00:00 2001
From: Peder <pederhp@hotmail.com>
Date: Sat, 13 Dec 2025 16:32:00 +0100
Subject: [PATCH 1/3] Fix message id mapping

---
 .../FunctionInvokingChatClient.cs             | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/Libraries/Microsoft.Extensions.AI/ChatCompletion/FunctionInvokingChatClient.cs b/src/Libraries/Microsoft.Extensions.AI/ChatCompletion/FunctionInvokingChatClient.cs
index 74f9bf554fa..b3885542de4 100644
--- a/src/Libraries/Microsoft.Extensions.AI/ChatCompletion/FunctionInvokingChatClient.cs
+++ b/src/Libraries/Microsoft.Extensions.AI/ChatCompletion/FunctionInvokingChatClient.cs
@@ -1448,10 +1448,23 @@ private static (List<ApprovalResultWithRequestMessage>? approvals, List<Approval
                     // The majority of the time, all FCC would be part of a single message, so no need to create a dictionary for this case.
                     // If we are dealing with multiple messages though, we need to keep track of them by their message ID.
                     messagesById = [];
-                    messagesById[currentMessage.MessageId ?? string.Empty] = currentMessage;
+
+                    // Use the effective key for the previous message, accounting for fallbackMessageId substitution.
+                    // If the message's MessageId was set to fallbackMessageId (because the original RequestMessage.MessageId was null),
+                    // we should use empty string as the key to match the lookup key used elsewhere.
+                    var previousMessageKey = currentMessage.MessageId == fallbackMessageId
+                        ? string.Empty
+                        : (currentMessage.MessageId ?? string.Empty);
+                    messagesById[previousMessageKey] = currentMessage;
                 }
 
-                _ = messagesById?.TryGetValue(resultWithRequestMessage.RequestMessage?.MessageId ?? string.Empty, out currentMessage);
+                // Use RequestMessage.MessageId for the lookup key, since that's the original message ID from the provider.
+                // We must use the same key for both lookup and storage to ensure proper grouping.
+                // Note: currentMessage.MessageId may differ from RequestMessage.MessageId because
+                // ConvertToFunctionCallContentMessage sets a fallbackMessageId when RequestMessage.MessageId is null.
+                var messageKey = resultWithRequestMessage.RequestMessage?.MessageId ?? string.Empty;
+
+                _ = messagesById?.TryGetValue(messageKey, out currentMessage);
 
                 if (currentMessage is null)
                 {
@@ -1463,7 +1476,7 @@ private static (List<ApprovalResultWithRequestMessage>? approvals, List<Approval
                 }
 
 #pragma warning disable IDE0058 // Temporary workaround for Roslyn analyzer issue (see https://github.com/dotnet/roslyn/issues/80499)
-                messagesById?[currentMessage.MessageId ?? string.Empty] = currentMessage;
+                messagesById?[messageKey] = currentMessage;
 #pragma warning restore IDE0058
             }
 

From d2778daa00bd35093dacc93ce502b3f0d1d00d9a Mon Sep 17 00:00:00 2001
From: Peder <pederhp@hotmail.com>
Date: Sat, 13 Dec 2025 17:00:20 +0100
Subject: [PATCH 2/3] Add test

---
 ...unctionInvokingChatClientApprovalsTests.cs | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs b/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs
index 7c42c0edaf9..0c618f5e9c7 100644
--- a/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs
+++ b/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs
@@ -186,6 +186,69 @@ public async Task ApprovedApprovalResponsesAreExecutedAsync()
         await InvokeAndAssertStreamingAsync(options, input, downstreamClientOutput, output, expectedDownstreamClientInput);
     }
 
+    /// <summary>
+    /// Regression test: When messages containing FunctionApprovalRequestContent and FunctionApprovalResponseContent
+    /// have null MessageId, all approvals from the same original message should still be grouped into a single
+    /// FunctionCallContent message when sent to the downstream client.
+    ///
+    /// Previously, a bug in ConvertToFunctionCallContentMessages caused a key mismatch when MessageId was null:
+    /// - Messages were stored in a dictionary under the fallbackMessageId key
+    /// - But lookups used (RequestMessage?.MessageId ?? "") which resolved to ""
+    /// - This caused each FCC to be placed in a separate message instead of being grouped
+    /// </summary>
+    [Fact]
+    public async Task ApprovedApprovalResponsesAreGroupedWhenMessageIdIsNullAsync()
+    {
+        var options = new ChatOptions
+        {
+            Tools =
+            [
+                new ApprovalRequiredAIFunction(AIFunctionFactory.Create(() => "Result 1", "Func1")),
+                new ApprovalRequiredAIFunction(AIFunctionFactory.Create((int i) => $"Result 2: {i}", "Func2")),
+            ]
+        };
+
+        // Key difference from other tests: MessageId is NOT set on the assistant message
+        List<ChatMessage> input =
+        [
+            new ChatMessage(ChatRole.User, "hello"),
+            new ChatMessage(ChatRole.Assistant,
+            [
+                new FunctionApprovalRequestContent("callId1", new FunctionCallContent("callId1", "Func1")),
+                new FunctionApprovalRequestContent("callId2", new FunctionCallContent("callId2", "Func2", arguments: new Dictionary<string, object?> { { "i", 42 } }))
+            ]), // Note: No MessageId set - this is the bug trigger
+            new ChatMessage(ChatRole.User,
+            [
+                new FunctionApprovalResponseContent("callId1", true, new FunctionCallContent("callId1", "Func1")),
+                new FunctionApprovalResponseContent("callId2", true, new FunctionCallContent("callId2", "Func2", arguments: new Dictionary<string, object?> { { "i", 42 } }))
+            ]),
+        ];
+
+        // Both FCCs should be in a SINGLE assistant message, not split across multiple messages
+        List<ChatMessage> expectedDownstreamClientInput =
+        [
+            new ChatMessage(ChatRole.User, "hello"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("callId1", "Func1"), new FunctionCallContent("callId2", "Func2", arguments: new Dictionary<string, object?> { { "i", 42 } })]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("callId1", result: "Result 1"), new FunctionResultContent("callId2", result: "Result 2: 42")]),
+        ];
+
+        List<ChatMessage> downstreamClientOutput =
+        [
+            new ChatMessage(ChatRole.Assistant, "world"),
+        ];
+
+        List<ChatMessage> output =
+        [
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("callId1", "Func1"), new FunctionCallContent("callId2", "Func2", arguments: new Dictionary<string, object?> { { "i", 42 } })]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("callId1", result: "Result 1"), new FunctionResultContent("callId2", result: "Result 2: 42")]),
+            new ChatMessage(ChatRole.Assistant, "world"),
+        ];
+
+        await InvokeAndAssertAsync(options, input, downstreamClientOutput, output, expectedDownstreamClientInput);
+
+        await InvokeAndAssertStreamingAsync(options, input, downstreamClientOutput, output, expectedDownstreamClientInput);
+    }
+
     [Fact]
     public async Task ApprovedApprovalResponsesFromSeparateFCCMessagesAreExecutedAsync()
     {

From 14eb134b7f85e8dc6043e4e08ca384854d963501 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Sun, 14 Dec 2025 23:34:03 -0500
Subject: [PATCH 3/3] Update
 test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs

---
 .../FunctionInvokingChatClientApprovalsTests.cs        | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs b/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs
index 0c618f5e9c7..93298ba2ac1 100644
--- a/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs
+++ b/test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientApprovalsTests.cs
@@ -186,16 +186,6 @@ public async Task ApprovedApprovalResponsesAreExecutedAsync()
         await InvokeAndAssertStreamingAsync(options, input, downstreamClientOutput, output, expectedDownstreamClientInput);
     }
 
-    /// <summary>
-    /// Regression test: When messages containing FunctionApprovalRequestContent and FunctionApprovalResponseContent
-    /// have null MessageId, all approvals from the same original message should still be grouped into a single
-    /// FunctionCallContent message when sent to the downstream client.
-    ///
-    /// Previously, a bug in ConvertToFunctionCallContentMessages caused a key mismatch when MessageId was null:
-    /// - Messages were stored in a dictionary under the fallbackMessageId key
-    /// - But lookups used (RequestMessage?.MessageId ?? "") which resolved to ""
-    /// - This caused each FCC to be placed in a separate message instead of being grouped
-    /// </summary>
     [Fact]
     public async Task ApprovedApprovalResponsesAreGroupedWhenMessageIdIsNullAsync()
     {