Automatically expand tool groups in FICC

Author: MackinnonBuck

src/Libraries/Microsoft.Extensions.AI/ChatCompletion/FunctionInvokingChatClient.cs

@@ -284,7 +284,7 @@ public override async Task<ChatResponse> GetResponseAsync(
         bool lastIterationHadConversationId = false; // whether the last iteration's response had a ConversationId set
         int consecutiveErrorCount = 0;
 
-        (Dictionary<string, AITool>? toolMap, bool anyToolsRequireApproval) = CreateToolsMap(AdditionalTools, options?.Tools); // all available tools, indexed by name
+        (Dictionary<string, AITool>? toolMap, bool anyToolsRequireApproval) = await CreateToolsMapAsync([AdditionalTools, options?.Tools], cancellationToken); // all available tools, indexed by name
 
         if (HasAnyApprovalContent(originalMessages))
         {
@@ -424,7 +424,7 @@ public override async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseA
         List<ChatResponseUpdate> updates = []; // updates from the current response
         int consecutiveErrorCount = 0;
 
-        (Dictionary<string, AITool>? toolMap, bool anyToolsRequireApproval) = CreateToolsMap(AdditionalTools, options?.Tools); // all available tools, indexed by name
+        (Dictionary<string, AITool>? toolMap, bool anyToolsRequireApproval) = await CreateToolsMapAsync([AdditionalTools, options?.Tools], cancellationToken); // all available tools, indexed by name
 
         // This is a synthetic ID since we're generating the tool messages instead of getting them from
         // the underlying provider. When emitting the streamed chunks, it's perfectly valid for us to
@@ -728,26 +728,51 @@ internal static void FixupHistories(
     /// The lists of tools to combine into a single dictionary. Tools from later lists are preferred
     /// over tools from earlier lists if they have the same name.
     /// </param>
-    private static (Dictionary<string, AITool>? ToolMap, bool AnyRequireApproval) CreateToolsMap(params ReadOnlySpan<IList<AITool>?> toolLists)
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
+    private static async ValueTask<(Dictionary<string, AITool>? ToolMap, bool AnyRequireApproval)> CreateToolsMapAsync(IList<AITool>?[] toolLists, CancellationToken cancellationToken)
     {
         Dictionary<string, AITool>? map = null;
         bool anyRequireApproval = false;
 
         foreach (var toolList in toolLists)
         {
-            if (toolList?.Count is int count && count > 0)
+            if (toolList is not null)
+            {
+                map ??= [];
+                var anyInListRequireApproval = await AddToolListAsync(map, toolList, cancellationToken).ConfigureAwait(false);
+                anyRequireApproval |= anyInListRequireApproval;
+            }
+        }
+
+        return (map, anyRequireApproval);
+
+        static async ValueTask<bool> AddToolListAsync(Dictionary<string, AITool> map, IEnumerable<AITool> tools, CancellationToken cancellationToken)
+        {
+#if NET
+            if (tools.TryGetNonEnumeratedCount(out var count) && count == 0)
             {
-                map ??= new(StringComparer.Ordinal);
-                for (int i = 0; i < count; i++)
+                return false;
+            }
+#endif
+            var anyRequireApproval = false;
+
+            foreach (var tool in tools)
+            {
+                if (tool is AIToolGroup toolGroup)
+                {
+                    var nestedTools = await toolGroup.GetToolsAsync(cancellationToken).ConfigureAwait(false);
+                    var nestedToolsRequireApproval = await AddToolListAsync(map, nestedTools, cancellationToken).ConfigureAwait(false);
+                    anyRequireApproval |= nestedToolsRequireApproval;
+                }
+                else
                 {
-                    AITool tool = toolList[i];
                     anyRequireApproval |= tool.GetService<ApprovalRequiredAIFunction>() is not null;
                     map[tool.Name] = tool;
                 }
             }
-        }
 
-        return (map, anyRequireApproval);
+            return anyRequireApproval;
+        }
     }
 
     /// <summary>

test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/FunctionInvokingChatClientTests.cs

@@ -1232,6 +1232,49 @@ public async Task ClonesChatOptionsAndResetContinuationTokenForBackgroundRespons
         Assert.Null(actualChatOptions!.ContinuationToken);
     }
 
+    [Fact]
+    public async Task ToolGroups_GetExpandedAutomatically()
+    {
+        var innerGroup = AIToolGroup.Create(
+            "InnerGroup",
+            "Inner group of tools",
+            new List<AITool>
+            {
+                AIFunctionFactory.Create((int i) => $"Result 2: {i}", "Func2"),
+            });
+
+        var outerGroup = AIToolGroup.Create(
+            "OuterGroup",
+            "Outer group of tools",
+            new List<AITool>
+            {
+                AIFunctionFactory.Create(() => "Result 1", "Func1"),
+                innerGroup,
+                AIFunctionFactory.Create((int i) => { }, "VoidReturn"),
+            });
+
+        ChatOptions options = new()
+        {
+            Tools = [outerGroup]
+        };
+
+        List<ChatMessage> plan =
+        [
+            new ChatMessage(ChatRole.User, "hello"),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("callId1", "Func1")]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("callId1", result: "Result 1")]),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("callId2", "Func2", arguments: new Dictionary<string, object?> { { "i", 42 } })]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("callId2", result: "Result 2: 42")]),
+            new ChatMessage(ChatRole.Assistant, [new FunctionCallContent("callId3", "VoidReturn", arguments: new Dictionary<string, object?> { { "i", 43 } })]),
+            new ChatMessage(ChatRole.Tool, [new FunctionResultContent("callId3", result: "Success: Function completed.")]),
+            new ChatMessage(ChatRole.Assistant, "world"),
+        ];
+
+        await InvokeAndAssertAsync(options, plan);
+
+        await InvokeAndAssertStreamingAsync(options, plan);
+    }
+
     private sealed class CustomSynchronizationContext : SynchronizationContext
     {
         public override void Post(SendOrPostCallback d, object? state)