Merge branch 'main' into bump-py-ver-20241121

dotnet/samples/Concepts/Filtering/TelemetryWithFilters.cs

@@ -147,7 +147,17 @@ public async Task OnFunctionInvocationAsync(FunctionInvocationContext context, F
 
                 logger.LogInformation("Function {FunctionName} succeeded.", context.Function.Name);
 
-                await this.LogFunctionResultAsync(context);
+                if (context.IsStreaming)
+                {
+                    // Overriding the result in a streaming scenario enables the filter to stream chunks 
+                    // back to the operation's origin without interrupting the data flow.
+                    var enumerable = context.Result.GetValue<IAsyncEnumerable<StreamingChatMessageContent>>();
+                    context.Result = new FunctionResult(context.Result, ProcessFunctionResultStreamingAsync(enumerable!));
+                }
+                else
+                {
+                    ProcessFunctionResult(context.Result);
+                }
             }
             catch (Exception exception)
             {
@@ -167,34 +177,43 @@ public async Task OnFunctionInvocationAsync(FunctionInvocationContext context, F
             }
         }
 
-        private async Task LogFunctionResultAsync(FunctionInvocationContext context)
+        private void ProcessFunctionResult(FunctionResult functionResult)
+        {
+            string? result = functionResult.GetValue<string>();
+            object? usage = functionResult.Metadata?["Usage"];
+
+            if (!string.IsNullOrWhiteSpace(result))
+            {
+                logger.LogTrace("Function result: {Result}", result);
+            }
+
+            if (logger.IsEnabled(LogLevel.Information) && usage is not null)
+            {
+                logger.LogInformation("Usage: {Usage}", JsonSerializer.Serialize(usage));
+            }
+        }
+
+        private async IAsyncEnumerable<StreamingChatMessageContent> ProcessFunctionResultStreamingAsync(IAsyncEnumerable<StreamingChatMessageContent> data)
         {
-            string? result = null;
             object? usage = null;
 
-            if (context.IsStreaming)
+            var stringBuilder = new StringBuilder();
+
+            await foreach (var item in data)
             {
-                var stringBuilder = new StringBuilder();
+                yield return item;
 
-                await foreach (var item in context.Result.GetValue<IAsyncEnumerable<StreamingChatMessageContent>>()!)
+                if (item.Content is not null)
                 {
-                    if (item.Content is not null)
-                    {
-                        stringBuilder.Append(item.Content);
-                    }
-
-                    usage = item.Metadata?["Usage"];
+                    stringBuilder.Append(item.Content);
                 }
 
-                result = stringBuilder.ToString();
-            }
-            else
-            {
-                result = context.Result.GetValue<string>();
-                usage = context.Result.Metadata?["Usage"];
+                usage = item.Metadata?["Usage"];
             }
 
-            if (result is not null)
+            var result = stringBuilder.ToString();
+
+            if (!string.IsNullOrWhiteSpace(result))
             {
                 logger.LogTrace("Function result: {Result}", result);
             }

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

@@ -78,6 +78,41 @@ public async Task FiltersAreExecutedCorrectlyAsync()
         Assert.Equal("Test chat response", result.ToString());
     }
 
+    [Fact]
+    public async Task FunctionSequenceIndexIsCorrectForConcurrentCallsAsync()
+    {
+        // Arrange
+        List<int> functionSequenceNumbers = [];
+        List<int> expectedFunctionSequenceNumbers = [0, 1, 0, 1];
+
+        var function1 = KernelFunctionFactory.CreateFromMethod((string parameter) => { return parameter; }, "Function1");
+        var function2 = KernelFunctionFactory.CreateFromMethod((string parameter) => { return parameter; }, "Function2");
+
+        var plugin = KernelPluginFactory.CreateFromFunctions("MyPlugin", [function1, function2]);
+
+        var kernel = this.GetKernelWithFilter(plugin, async (context, next) =>
+        {
+            functionSequenceNumbers.Add(context.FunctionSequenceIndex);
+
+            await next(context);
+        });
+
+        this._messageHandlerStub.ResponsesToReturn = GetFunctionCallingResponses();
+
+        // Act
+        var result = await kernel.InvokePromptAsync("Test prompt", new(new OpenAIPromptExecutionSettings
+        {
+            FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(options: new()
+            {
+                AllowParallelCalls = true,
+                AllowConcurrentInvocation = true
+            })
+        }));
+
+        // Assert
+        Assert.Equal(expectedFunctionSequenceNumbers, functionSequenceNumbers);
+    }
+
     [Fact]
     public async Task FiltersAreExecutedCorrectlyOnStreamingAsync()
     {

dotnet/src/SemanticKernel.Abstractions/Filters/AutoFunctionInvocation/AutoFunctionInvocationContext.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using Microsoft.SemanticKernel.ChatCompletion;
 
@@ -9,7 +8,6 @@ namespace Microsoft.SemanticKernel;
 /// <summary>
 /// Class with data related to automatic function invocation.
 /// </summary>
-[Experimental("SKEXP0001")]
 public class AutoFunctionInvocationContext
 {
     /// <summary>

dotnet/src/SemanticKernel.Abstractions/Filters/AutoFunctionInvocation/IAutoFunctionInvocationFilter.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System;
-using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 
 namespace Microsoft.SemanticKernel;
@@ -11,7 +10,6 @@ namespace Microsoft.SemanticKernel;
 /// <summary>
 /// Interface for filtering actions during automatic function invocation.
 /// </summary>
-[Experimental("SKEXP0001")]
 public interface IAutoFunctionInvocationFilter
 {
     /// <summary>

dotnet/src/SemanticKernel.Abstractions/Filters/Function/FunctionInvocationContext.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 
 namespace Microsoft.SemanticKernel;
@@ -38,7 +37,6 @@ internal FunctionInvocationContext(Kernel kernel, KernelFunction function, Kerne
     /// <summary>
     /// Boolean flag which indicates whether a filter is invoked within streaming or non-streaming mode.
     /// </summary>
-    [Experimental("SKEXP0001")]
     public bool IsStreaming { get; init; }
 
     /// <summary>

dotnet/src/SemanticKernel.Abstractions/Filters/Prompt/PromptRenderContext.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Threading;
+
 namespace Microsoft.SemanticKernel;
 
 /// <summary>
@@ -37,7 +37,6 @@ internal PromptRenderContext(Kernel kernel, KernelFunction function, KernelArgum
     /// <summary>
     /// Boolean flag which indicates whether a filter is invoked within streaming or non-streaming mode.
     /// </summary>
-    [Experimental("SKEXP0001")]
     public bool IsStreaming { get; init; }
 
     /// <summary>

dotnet/src/SemanticKernel.Abstractions/Kernel.cs

@@ -144,7 +144,6 @@ public Kernel Clone() =>
     /// <summary>
     /// Gets the collection of auto function invocation filters available through the kernel.
     /// </summary>
-    [Experimental("SKEXP0001")]
     public IList<IAutoFunctionInvocationFilter> AutoFunctionInvocationFilters =>
         this._autoFunctionInvocationFilters ??
         Interlocked.CompareExchange(ref this._autoFunctionInvocationFilters, [], null) ??