.Net: Update KernelFunctionInvokingChatClient as a specialization of MEAI.FunctionInvokingChatClient

dotnet/src/Connectors/Connectors.Ollama/Extensions/OllamaServiceCollectionExtensions.cs

@@ -155,16 +155,16 @@ public static IServiceCollection AddOllamaChatCompletion(
         {
             var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
 
-            var builder = ((IChatClient)new OllamaApiClient(endpoint, modelId))
-                .AsBuilder()
-                .UseFunctionInvocation(loggerFactory, config => config.MaximumIterationsPerRequest = MaxInflightAutoInvokes);
+            var ollamaClient = (IChatClient)new OllamaApiClient(endpoint, modelId);
 
             if (loggerFactory is not null)
             {
-                builder.UseLogging(loggerFactory);
+                ollamaClient.AsBuilder().UseLogging(loggerFactory).Build();
             }
 
-            return builder.Build(serviceProvider).AsChatCompletionService(serviceProvider);
+            return ollamaClient
+                .AsKernelFunctionInvokingChatClient(loggerFactory)
+                .AsChatCompletionService();
         });
     }
 
@@ -190,16 +190,16 @@ public static IServiceCollection AddOllamaChatCompletion(
 
             var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
 
-            var builder = ((IChatClient)new OllamaApiClient(httpClient, modelId))
-                .AsBuilder()
-                .UseFunctionInvocation(loggerFactory, config => config.MaximumIterationsPerRequest = MaxInflightAutoInvokes);
+            var ollamaClient = (IChatClient)new OllamaApiClient(httpClient, modelId);
 
             if (loggerFactory is not null)
             {
-                builder.UseLogging(loggerFactory);
+                ollamaClient.AsBuilder().UseLogging(loggerFactory).Build();
             }
 
-            return builder.Build(serviceProvider).AsChatCompletionService(serviceProvider);
+            return ollamaClient
+                .AsKernelFunctionInvokingChatClient(loggerFactory)
+                .AsChatCompletionService();
         });
     }
 
@@ -231,15 +231,16 @@ public static IServiceCollection AddOllamaChatCompletion(
             }
 
             var builder = ((IChatClient)ollamaClient)
-                .AsBuilder()
-                .UseFunctionInvocation(loggerFactory, config => config.MaximumIterationsPerRequest = MaxInflightAutoInvokes);
+                .AsKernelFunctionInvokingChatClient(loggerFactory)
+                .AsBuilder();
 
             if (loggerFactory is not null)
             {
                 builder.UseLogging(loggerFactory);
             }
 
-            return builder.Build(serviceProvider).AsChatCompletionService(serviceProvider);
+            return builder.Build(serviceProvider)
+                .AsChatCompletionService(serviceProvider);
         });
     }
 
@@ -355,26 +356,4 @@ public static IServiceCollection AddOllamaTextEmbeddingGeneration(
     }
 
     #endregion
-
-    #region Private
-
-    /// <summary>
-    /// The maximum number of auto-invokes that can be in-flight at any given time as part of the current
-    /// asynchronous chain of execution.
-    /// </summary>
-    /// <remarks>
-    /// This is a fail-safe mechanism. If someone accidentally manages to set up execution settings in such a way that
-    /// auto-invocation is invoked recursively, and in particular where a prompt function is able to auto-invoke itself,
-    /// we could end up in an infinite loop. This const is a backstop against that happening. We should never come close
-    /// to this limit, but if we do, auto-invoke will be disabled for the current flow in order to prevent runaway execution.
-    /// With the current setup, the way this could possibly happen is if a prompt function is configured with built-in
-    /// execution settings that opt-in to auto-invocation of everything in the kernel, in which case the invocation of that
-    /// prompt function could advertize itself as a candidate for auto-invocation. We don't want to outright block that,
-    /// if that's something a developer has asked to do (e.g. it might be invoked with different arguments than its parent
-    /// was invoked with), but we do want to limit it. This limit is arbitrary and can be tweaked in the future and/or made
-    /// configurable should need arise.
-    /// </remarks>
-    private const int MaxInflightAutoInvokes = 128;
-
-    #endregion
 }

dotnet/src/Connectors/Connectors.OpenAI.UnitTests/Core/AutoFunctionInvocationFilterChatClientTests.cs

@@ -736,7 +736,7 @@ public void Dispose()
     private static object? GetLastFunctionResultFromChatResponse(ChatResponse chatResponse)
     {
         Assert.NotEmpty(chatResponse.Messages);
-        var chatMessage = chatResponse.Messages[^1];
+        var chatMessage = chatResponse.Messages.Where(m => m.Role == ChatRole.Tool).Last();
 
         Assert.NotEmpty(chatMessage.Contents);
         Assert.Contains(chatMessage.Contents, c => c is Microsoft.Extensions.AI.FunctionResultContent);

dotnet/src/Functions/Functions.OpenApi/RestApiOperationRunner.cs

@@ -13,6 +13,8 @@
 using System.Threading.Tasks;
 using Microsoft.SemanticKernel.Http;
 
+#pragma warning disable CA1859 // Use concrete types when possible for improved performance
+
 namespace Microsoft.SemanticKernel.Plugins.OpenApi;
 
 /// <summary>

dotnet/src/IntegrationTests/Plugins/Core/SessionsPythonPluginTests.cs

@@ -1,19 +1,19 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System;
-using System.Threading.Tasks;
-using Xunit;
-using Microsoft.SemanticKernel.Plugins.Core.CodeInterpreter;
-using Microsoft.Extensions.Configuration;
-using SemanticKernel.IntegrationTests.TestSettings;
+using System.Collections.Generic;
 using System.Net.Http;
-using Azure.Identity;
+using System.Threading.Tasks;
 using Azure.Core;
-using System.Collections.Generic;
-using Microsoft.SemanticKernel;
+using Azure.Identity;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.ChatCompletion;
 using Microsoft.SemanticKernel.Connectors.AzureOpenAI;
+using Microsoft.SemanticKernel.Plugins.Core.CodeInterpreter;
+using SemanticKernel.IntegrationTests.TestSettings;
+using Xunit;
 
 namespace SemanticKernel.IntegrationTests.Plugins.Core;
 

dotnet/src/InternalUtilities/connectors/AI/FunctionCalling/FunctionCallsProcessor.cs

@@ -51,7 +51,7 @@ internal sealed class FunctionCallsProcessor
     /// will be disabled. This is a safeguard against possible runaway execution if the model routinely re-requests
     /// the same function over and over.
     /// </remarks>
-    private const int MaximumAutoInvokeAttempts = 128;
+    internal const int MaximumAutoInvokeAttempts = 128;
 
     /// <summary>Tracking <see cref="AsyncLocal{Int32}"/> for <see cref="MaxInflightAutoInvokes"/>.</summary>
     /// <remarks>

dotnet/src/SemanticKernel.Abstractions/AI/ChatClient/ChatOptionsExtensions.cs

@@ -14,7 +14,6 @@ namespace Microsoft.SemanticKernel.ChatCompletion;
 internal static class ChatOptionsExtensions
 {
     internal const string KernelKey = "AutoInvokingKernel";
-    internal const string IsStreamingKey = "AutoInvokingIsStreaming";
     internal const string ChatMessageContentKey = "AutoInvokingChatCompletionContent";
     internal const string PromptExecutionSettingsKey = "AutoInvokingPromptExecutionSettings";