Address PR #5668 review feedback round 2

- OutputConverter FRC: emit string results as raw text (no JSON-quoting),
  matching the wire contract for function_call_output.output.
- OutputConverter FCC: validate non-empty CallId before closing the in-flight
  text message, so a skipped FCC no longer breaks output-item boundaries.
- ToolApprovalIdMap.Record: take pre-serialized arguments JSON (string) and
  primitive callId/name. Drops [RequiresUnreferencedCode]/[RequiresDynamicCode]
  so trim/AOT warnings stop propagating to call sites.
- ToolApprovalIdMap.Record: no-op when callId or name is empty.
- Tests: dedup duplicate ConvertItemsToMessages_McpApprovalResponse no-mapping
  test; add coverage for empty-CallId boundary, raw-string FRC payload, and
  Record empty-key no-op.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: alliscode

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/OutputConverter.cs

@@ -120,6 +120,11 @@ public static async IAsyncEnumerable<ResponseStreamEvent> ConvertUpdatesToEvents
 
                     case FunctionCallContent functionCall:
                     {
+                        if (functionCall.CallId is not { Length: > 0 })
+                        {
+                            break;
+                        }
+
                         foreach (var evt in CloseCurrentMessage(currentMessageBuilder, currentTextBuilder, accumulatedText))
                         {
                             yield return evt;
@@ -130,11 +135,6 @@ public static async IAsyncEnumerable<ResponseStreamEvent> ConvertUpdatesToEvents
                         accumulatedText = null;
                         previousMessageId = null;
 
-                        if (functionCall.CallId is not { Length: > 0 })
-                        {
-                            break;
-                        }
-
                         var arguments = functionCall.Arguments is not null
                             ? JsonSerializer.Serialize(functionCall.Arguments)
                             : "{}";
@@ -194,12 +194,19 @@ public static async IAsyncEnumerable<ResponseStreamEvent> ConvertUpdatesToEvents
                         // wireId↔afRequestId mapping in the session state bag for later lookup
                         // when the matching `mcp_approval_response` arrives on a subsequent turn.
                         var wireId = ToolApprovalIdMap.ComputeWireId(approvalRequest.RequestId);
-                        ToolApprovalIdMap.Record(stateBag, wireId, approvalRequest.RequestId, approvalFunctionCall);
 
                         var approvalArguments = approvalFunctionCall.Arguments is not null
                             ? JsonSerializer.Serialize(approvalFunctionCall.Arguments)
                             : "{}";
 
+                        ToolApprovalIdMap.Record(
+                            stateBag,
+                            wireId,
+                            approvalRequest.RequestId,
+                            approvalFunctionCall.CallId,
+                            approvalFunctionCall.Name,
+                            approvalArguments);
+
                         var approvalItem = new OutputItemMcpApprovalRequest(
                             wireId,
                             "agent_framework",
@@ -272,17 +279,17 @@ public static async IAsyncEnumerable<ResponseStreamEvent> ConvertUpdatesToEvents
                         accumulatedText = null;
                         previousMessageId = null;
 
-                        var outputJson = functionResult.Result switch
+                        var outputText = functionResult.Result switch
                         {
-                            null => "null",
-                            string s => JsonSerializer.Serialize(s),
+                            null => string.Empty,
+                            string s => s,
                             _ => JsonSerializer.Serialize(functionResult.Result),
                         };
 
                         var itemId = GenerateItemId("fc");
                         var outputItem = new OutputItemFunctionToolCallOutput(
                             functionResult.CallId,
-                            BinaryData.FromString(outputJson));
+                            BinaryData.FromString(outputText));
 
                         var outputBuilder = stream.AddOutputItem<OutputItemFunctionToolCallOutput>(itemId);
                         yield return outputBuilder.EmitAdded(outputItem);

dotnet/src/Microsoft.Agents.AI.Foundry.Hosting/ToolApprovalIdMap.cs

@@ -2,10 +2,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Security.Cryptography;
 using System.Text;
-using System.Text.Json;
 using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI.Foundry.Hosting;
@@ -62,27 +60,31 @@ public static string ComputeWireId(string afRequestId)
 
     /// <summary>
     /// Records the wire-id → approval-entry mapping in the supplied state bag.
+    /// Arguments are passed as already-serialized JSON to keep this method
+    /// trim/AOT-friendly (no polymorphic <c>object</c> serialization here).
+    /// No-op when <paramref name="callId"/> or <paramref name="name"/> is empty —
+    /// without those fields the entry cannot be used to faithfully reconstruct
+    /// the original <see cref="FunctionCallContent"/> on the inbound side.
     /// </summary>
-    [RequiresUnreferencedCode("FunctionCallContent.Arguments serialization may require types that cannot be statically analyzed.")]
-    [RequiresDynamicCode("FunctionCallContent.Arguments serialization may require runtime code generation.")]
-    public static void Record(AgentSessionStateBag? stateBag, string wireId, string afRequestId, FunctionCallContent functionCall)
+    public static void Record(AgentSessionStateBag? stateBag, string wireId, string afRequestId, string? callId, string? name, string? argumentsJson)
     {
         if (stateBag is null)
         {
             return;
         }
 
-        ArgumentNullException.ThrowIfNull(functionCall);
+        if (string.IsNullOrEmpty(callId) || string.IsNullOrEmpty(name))
+        {
+            return;
+        }
 
         var map = LoadMap(stateBag);
         map[wireId] = new ApprovalEntry
         {
             AfRequestId = afRequestId,
-            CallId = functionCall.CallId,
-            Name = functionCall.Name,
-            Arguments = functionCall.Arguments is not null
-                ? JsonSerializer.Serialize(functionCall.Arguments)
-                : null,
+            CallId = callId!,
+            Name = name!,
+            Arguments = argumentsJson,
         };
         stateBag.SetValue(StateBagKey, map);
     }

dotnet/tests/Microsoft.Agents.AI.Foundry.Hosting.UnitTests/InputConverterTests.cs

@@ -783,6 +783,11 @@ public void ConvertItemsToMessages_McpApprovalRequest_ProducesToolApprovalReques
     [Fact]
     public void ConvertItemsToMessages_McpApprovalResponse_ThrowsWhenNoMapping()
     {
+        // Without a recorded ApprovalEntry the converter cannot reconstruct the original
+        // function call faithfully — any placeholder it produced would still fail downstream
+        // (FICC has no tool to invoke; Azure's stored function_call can't pair with the
+        // synthetic id). Fail fast with a clear error instead of continuing into a confusing
+        // HTTP 400 deep inside the agent loop.
         var wireId = "mcpr_" + new string('a', 50);
         var item = new MCPApprovalResponse(approvalRequestId: wireId, approve: true);
 
@@ -800,7 +805,9 @@ public void ConvertItemsToMessages_McpApprovalResponse_ResolvesAfRequestIdFromSt
             stateBag,
             wireId,
             AfRequestId,
-            new FunctionCallContent("call_xyz", "issue_refund", new Dictionary<string, object?> { ["order_id"] = 123 }));
+            "call_xyz",
+            "issue_refund",
+            "{\"order_id\":123}");
 
         var item = new MCPApprovalResponse(approvalRequestId: wireId, approve: false);
 
@@ -848,7 +855,9 @@ public void ConvertOutputItemsToMessages_McpApprovalResponse_ProducesToolApprova
             stateBag,
             wireId,
             AfRequestId,
-            new FunctionCallContent("call_history", "delete_file", new Dictionary<string, object?> { ["path"] = "/tmp/x" }));
+            "call_history",
+            "delete_file",
+            "{\"path\":\"/tmp/x\"}");
 
         var item = new OutputItemMcpApprovalResponseResource(
             id: "ar_history_id",
@@ -866,21 +875,6 @@ public void ConvertOutputItemsToMessages_McpApprovalResponse_ProducesToolApprova
         Assert.Equal("delete_file", fcc.Name);
     }
 
-    [Fact]
-    public void ConvertItemsToMessages_McpApprovalResponse_NoMapping_Throws()
-    {
-        // Without a recorded ApprovalEntry the converter cannot reconstruct the original
-        // function call faithfully — any placeholder it produced would still fail downstream
-        // (FICC has no tool to invoke; Azure's stored function_call can't pair with the
-        // synthetic id). Fail fast with a clear error instead of continuing into a confusing
-        // HTTP 400 deep inside the agent loop.
-        var wireId = "mcpr_" + new string('c', 50);
-        var item = new MCPApprovalResponse(approvalRequestId: wireId, approve: true);
-
-        var ex = Assert.Throws<InvalidOperationException>(() => InputConverter.ConvertItemsToMessages([item]));
-        Assert.Contains(wireId, ex.Message);
-    }
-
     [Fact]
     public void ConvertItemsToMessages_McpApprovalRequest_MalformedArguments_PreservesRaw()
     {
@@ -898,6 +892,28 @@ public void ConvertItemsToMessages_McpApprovalRequest_MalformedArguments_Preserv
         Assert.Equal("not valid json", fc.Arguments!["_raw"]?.ToString());
     }
 
+    [Fact]
+    public void ToolApprovalIdMap_Record_EmptyCallId_IsNoOp()
+    {
+        var stateBag = new AgentSessionStateBag();
+        var wireId = "mcpr_" + new string('d', 50);
+
+        ToolApprovalIdMap.Record(stateBag, wireId, "ficc_x", callId: string.Empty, name: "tool", argumentsJson: "{}");
+
+        Assert.Null(ToolApprovalIdMap.ResolveEntry(stateBag, wireId));
+    }
+
+    [Fact]
+    public void ToolApprovalIdMap_Record_EmptyName_IsNoOp()
+    {
+        var stateBag = new AgentSessionStateBag();
+        var wireId = "mcpr_" + new string('e', 50);
+
+        ToolApprovalIdMap.Record(stateBag, wireId, "ficc_x", callId: "call_xyz", name: string.Empty, argumentsJson: "{}");
+
+        Assert.Null(ToolApprovalIdMap.ResolveEntry(stateBag, wireId));
+    }
+
     // ── input_file data-URI decoding (TryDecodeTextDataUri) ──
 
     [Fact]

dotnet/tests/Microsoft.Agents.AI.Foundry.Hosting.UnitTests/OutputConverterTests.cs

@@ -590,6 +590,51 @@ public async Task ConvertUpdatesToEventsAsync_FunctionCallThenResult_EmitsPaired
         Assert.IsType<ResponseCompletedEvent>(events[^1]);
     }
 
+    // K-05: An FCC with an empty CallId is dropped without disturbing in-flight text.
+    [Fact]
+    public async Task ConvertUpdatesToEventsAsync_FunctionCallEmptyCallIdMidText_PreservesTextBoundaryAsync()
+    {
+        var (stream, _) = CreateTestStream();
+        var updates = new[]
+        {
+            new AgentResponseUpdate { MessageId = "msg_1", Contents = [new MeaiTextContent("Hello, ")] },
+            new AgentResponseUpdate { Contents = [new FunctionCallContent(string.Empty, "skipped", new Dictionary<string, object?>())] },
+            new AgentResponseUpdate { MessageId = "msg_1", Contents = [new MeaiTextContent("world!")] },
+        };
+
+        var events = new List<ResponseStreamEvent>();
+        await foreach (var evt in OutputConverter.ConvertUpdatesToEventsAsync(ToAsync(updates), stream))
+        {
+            events.Add(evt);
+        }
+
+        // The FCC is skipped (no CallId), and because we now validate CallId before
+        // closing the in-flight assistant message, both text deltas land in the same
+        // output item — only one message-added event is emitted.
+        Assert.Single(events.OfType<ResponseOutputItemAddedEvent>());
+        Assert.Equal(2, events.OfType<ResponseTextDeltaEvent>().Count());
+        Assert.IsType<ResponseCompletedEvent>(events[^1]);
+    }
+
+    // K-06: FRC string results are emitted as raw text on the wire (not JSON-quoted).
+    [Fact]
+    public async Task ConvertUpdatesToEventsAsync_FunctionResultStringPayload_EmittedAsRawTextAsync()
+    {
+        var (stream, _) = CreateTestStream();
+        var update = new AgentResponseUpdate { Contents = [new FunctionResultContent("call_1", "sunny")] };
+
+        var events = new List<ResponseStreamEvent>();
+        await foreach (var evt in OutputConverter.ConvertUpdatesToEventsAsync(ToAsync(new[] { update }), stream))
+        {
+            events.Add(evt);
+        }
+
+        var added = Assert.Single(events.OfType<ResponseOutputItemAddedEvent>());
+        var output = Assert.IsType<OutputItemFunctionToolCallOutput>(added.Item);
+        // String FRC payloads must not be double-encoded — `sunny`, not `"sunny"`.
+        Assert.Equal("sunny", output.Output.ToString());
+    }
+
     // L-01
     [Fact]
     public async Task ConvertUpdatesToEventsAsync_ExecutorInvokedEvent_EmitsWorkflowActionItemAsync()