fix: project copilot tool results into workflows

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

sidecar/src/Aryx.AgentHost/Services/AryxCopilotAgent.cs

@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
@@ -104,6 +105,7 @@ internal sealed class AryxCopilotAgent : AIAgent, IAsyncDisposable
         try
         {
             Channel<AgentResponseUpdate> channel = Channel.CreateUnbounded<AgentResponseUpdate>();
+            ConcurrentDictionary<string, string> toolNamesByCallId = new(StringComparer.Ordinal);
 
             using IDisposable subscription = copilotSession.On(evt =>
             {
@@ -114,9 +116,19 @@ internal sealed class AryxCopilotAgent : AIAgent, IAsyncDisposable
                         break;
 
                     case AssistantMessageEvent assistantMessage:
+                        TrackToolRequestNames(toolNamesByCallId, assistantMessage.Data?.ToolRequests);
                         channel.Writer.TryWrite(ConvertToAgentResponseUpdate(assistantMessage));
                         break;
 
+                    case ToolExecutionCompleteEvent toolExecutionComplete:
+                        AgentResponseUpdate? toolResultUpdate = ConvertToAgentResponseUpdate(toolExecutionComplete, toolNamesByCallId);
+                        if (toolResultUpdate is not null)
+                        {
+                            channel.Writer.TryWrite(toolResultUpdate);
+                        }
+
+                        break;
+
                     case AssistantUsageEvent usageEvent:
                         channel.Writer.TryWrite(ConvertToAgentResponseUpdate(usageEvent));
                         break;
@@ -232,16 +244,6 @@ internal sealed class AryxCopilotAgent : AIAgent, IAsyncDisposable
                 continue;
             }
 
-            // Only project handoff tool calls as FunctionCallContent for the Agent Framework.
-            // Other tool calls (ask_user, MCP tools, etc.) are resolved by the Copilot SDK
-            // internally and must not be surfaced, because AIAgentHostExecutor tracks every
-            // FunctionCallContent as an outstanding request.  An unmatched request prevents
-            // the executor from emitting a TurnToken, which stalls group-chat advancement.
-            if (!IsHandoffToolName(toolRequest.Name))
-            {
-                continue;
-            }
-
             contents.Add(new FunctionCallContent(
                 toolRequest.ToolCallId,
                 toolRequest.Name,
@@ -251,6 +253,26 @@ internal sealed class AryxCopilotAgent : AIAgent, IAsyncDisposable
         return contents;
     }
 
+    internal static FunctionResultContent? TryCreateToolResultContent(
+        ToolExecutionCompleteEvent toolExecutionComplete,
+        string? toolName = null)
+    {
+        // Regular Copilot tools need their result projected back into AF so the function call
+        // remains part of workflow-visible history. Handoff tools are finalized separately by
+        // HandoffAgentExecutor, which already injects its own "Transferred." result.
+        string? toolCallId = toolExecutionComplete.Data?.ToolCallId?.Trim();
+        if (string.IsNullOrWhiteSpace(toolCallId) || IsHandoffToolName(toolName))
+        {
+            return null;
+        }
+
+        string result = ResolveToolResultText(toolExecutionComplete.Data);
+        return new FunctionResultContent(toolCallId, result)
+        {
+            RawRepresentation = toolExecutionComplete,
+        };
+    }
+
     private static bool IsHandoffToolName(string? name)
     {
         return !string.IsNullOrWhiteSpace(name)
@@ -441,6 +463,36 @@ internal sealed class AryxCopilotAgent : AIAgent, IAsyncDisposable
         };
     }
 
+    private AgentResponseUpdate? ConvertToAgentResponseUpdate(
+        ToolExecutionCompleteEvent toolExecutionComplete,
+        ConcurrentDictionary<string, string> toolNamesByCallId)
+    {
+        string? toolCallId = toolExecutionComplete.Data?.ToolCallId?.Trim();
+        if (string.IsNullOrWhiteSpace(toolCallId))
+        {
+            return null;
+        }
+
+        string? toolName = null;
+        if (toolNamesByCallId.TryRemove(toolCallId, out string? trackedToolName))
+        {
+            toolName = trackedToolName;
+        }
+
+        FunctionResultContent? toolResult = TryCreateToolResultContent(toolExecutionComplete, toolName);
+        if (toolResult is null)
+        {
+            return null;
+        }
+
+        return new AgentResponseUpdate(ChatRole.Tool, [toolResult])
+        {
+            AgentId = Id,
+            MessageId = toolCallId,
+            CreatedAt = toolExecutionComplete.Timestamp,
+        };
+    }
+
     private AgentResponseUpdate ConvertToAgentResponseUpdate(SessionEvent sessionEvent)
     {
         AIContent content = new()
@@ -455,6 +507,45 @@ internal sealed class AryxCopilotAgent : AIAgent, IAsyncDisposable
         };
     }
 
+    private static void TrackToolRequestNames(
+        ConcurrentDictionary<string, string> toolNamesByCallId,
+        AssistantMessageDataToolRequestsItem[]? toolRequests)
+    {
+        if (toolRequests is not { Length: > 0 })
+        {
+            return;
+        }
+
+        foreach (AssistantMessageDataToolRequestsItem toolRequest in toolRequests)
+        {
+            string? toolCallId = toolRequest.ToolCallId?.Trim();
+            string? toolName = toolRequest.Name?.Trim();
+            if (string.IsNullOrWhiteSpace(toolCallId) || string.IsNullOrWhiteSpace(toolName))
+            {
+                continue;
+            }
+
+            toolNamesByCallId[toolCallId] = toolName;
+        }
+    }
+
+    private static string ResolveToolResultText(ToolExecutionCompleteData? toolExecutionCompleteData)
+    {
+        if (toolExecutionCompleteData is null)
+        {
+            return string.Empty;
+        }
+
+        if (toolExecutionCompleteData.Success)
+        {
+            return toolExecutionCompleteData.Result?.Content
+                ?? toolExecutionCompleteData.Result?.DetailedContent
+                ?? string.Empty;
+        }
+
+        return toolExecutionCompleteData.Error?.Message ?? string.Empty;
+    }
+
     private static Dictionary<string, object?>? ParseToolArguments(object? arguments)
     {
         if (arguments is null)

sidecar/src/Aryx.AgentHost/Services/CopilotTurnExecutionState.cs

@@ -89,7 +89,16 @@ internal sealed class CopilotTurnExecutionState
             case ToolExecutionStartEvent toolExecutionStart
                 when !string.IsNullOrWhiteSpace(toolExecutionStart.Data?.ToolCallId)
                     && !string.IsNullOrWhiteSpace(toolExecutionStart.Data?.ToolName):
-                ToolNamesByCallId[toolExecutionStart.Data.ToolCallId.Trim()] = toolExecutionStart.Data.ToolName.Trim();
+                string toolCallId = toolExecutionStart.Data.ToolCallId.Trim();
+                string toolName = toolExecutionStart.Data.ToolName.Trim();
+                ToolNamesByCallId[toolCallId] = toolName;
+                ActiveAgent = agent;
+                AgentActivityEventDto? toolActivity = CreateToolCallingActivity(agent, toolName, toolCallId);
+                if (toolActivity is not null)
+                {
+                    _pendingEvents.Enqueue(toolActivity);
+                }
+
                 QueueMessageReclassifiedIfNeeded(_lastObservedMessageId);
                 break;
             case AssistantIntentEvent intentEvent:
@@ -278,6 +287,29 @@ internal sealed class CopilotTurnExecutionState
         };
     }
 
+    private AgentActivityEventDto? CreateToolCallingActivity(
+        AgentIdentity agent,
+        string toolName,
+        string toolCallId)
+    {
+        if (toolName.StartsWith("handoff_to_", StringComparison.Ordinal))
+        {
+            return null;
+        }
+
+        return new AgentActivityEventDto
+        {
+            Type = "agent-activity",
+            RequestId = _command.RequestId,
+            SessionId = _command.SessionId,
+            ActivityType = "tool-calling",
+            AgentId = agent.AgentId,
+            AgentName = agent.AgentName,
+            ToolName = toolName,
+            ToolCallId = toolCallId,
+        };
+    }
+
     private MessageReclassifiedEventDto CreateMessageReclassifiedEvent(string messageId)
     {
         return new MessageReclassifiedEventDto

sidecar/src/Aryx.AgentHost/Services/WorkflowRequestInfoInterpreter.cs

@@ -57,12 +57,17 @@ internal static class WorkflowRequestInfoInterpreter
         };
     }
 
-    private static AgentActivityEventDto CreateToolCallingActivity(
+    private static AgentActivityEventDto? CreateToolCallingActivity(
         RunTurnCommandDto command,
         AgentIdentity activeAgent,
         ToolRequestInterpretation tool,
         ConcurrentDictionary<string, string> toolNamesByCallId)
     {
+        if (tool.ToolCallId is not null && toolNamesByCallId.ContainsKey(tool.ToolCallId))
+        {
+            return null;
+        }
+
         TrackToolCallId(toolNamesByCallId, tool.ToolCallId, tool.ToolName);
 
         return new AgentActivityEventDto