Merge branch 'main' into chore/zengin-manifest

Signed-off-by: Vincent Biret <[email protected]>

Author: baywet

dotnet/samples/Concepts/Plugins/OpenApiPlugin_Telemetry.cs

@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Plugins.OpenApi;
+
+namespace Plugins;
+
+/// <summary>
+/// Sample with demonstration of logging in OpenAPI plugins.
+/// </summary>
+public sealed class OpenApiPlugin_Telemetry(ITestOutputHelper output) : BaseTest(output)
+{
+    /// <summary>
+    /// Default logging in OpenAPI plugins.
+    /// It's possible to use HTTP logging middleware in ASP.NET applications to log information about HTTP request, headers, body, response etc.
+    /// More information here: <see href="https://learn.microsoft.com/en-us/aspnet/core/fundamentals/http-logging"/>.
+    /// For custom logging logic, use <see cref="DelegatingHandler"/>.
+    /// More information here: <see href="https://learn.microsoft.com/en-us/aspnet/web-api/overview/advanced/http-message-handlers"/>.
+    /// </summary>
+    [Fact]
+    public async Task LoggingAsync()
+    {
+        // Arrange
+        using var stream = File.OpenRead("Resources/Plugins/RepairServicePlugin/repair-service.json");
+        using HttpClient httpClient = new();
+
+        var kernelBuilder = Kernel.CreateBuilder();
+
+        // If ILoggerFactory is registered in kernel's DI container, it will be used for logging purposes in OpenAPI functionality.
+        kernelBuilder.Services.AddSingleton<ILoggerFactory>(this.LoggerFactory);
+
+        var kernel = kernelBuilder.Build();
+
+        var plugin = await OpenApiKernelPluginFactory.CreateFromOpenApiAsync(
+            "RepairService",
+            stream,
+            new OpenApiFunctionExecutionParameters(httpClient)
+            {
+                IgnoreNonCompliantErrors = true,
+                EnableDynamicPayload = false,
+                // For non-DI scenarios, it's possible to set ILoggerFactory in execution parameters when creating a plugin.
+                // If ILoggerFactory is provided in both ways through the kernel's DI container and execution parameters,
+                // the one from execution parameters will be used.
+                LoggerFactory = kernel.LoggerFactory
+            });
+
+        kernel.Plugins.Add(plugin);
+
+        var arguments = new KernelArguments
+        {
+            ["payload"] = """{ "title": "Engine oil change", "description": "Need to drain the old engine oil and replace it with fresh oil.", "assignedTo": "", "date": "", "image": "" }""",
+            ["content-type"] = "application/json"
+        };
+
+        // Create Repair
+        var result = await plugin["createRepair"].InvokeAsync(kernel, arguments);
+        Console.WriteLine(result.ToString());
+
+        // List All Repairs
+        result = await plugin["listRepairs"].InvokeAsync(kernel, arguments);
+        var repairs = JsonSerializer.Deserialize<Repair[]>(result.ToString());
+
+        Assert.True(repairs?.Length > 0);
+
+        var id = repairs[repairs.Length - 1].Id;
+
+        // Update Repair
+        arguments = new KernelArguments
+        {
+            ["payload"] = $"{{ \"id\": {id}, \"assignedTo\": \"Karin Blair\", \"date\": \"2024-04-16\", \"image\": \"https://www.howmuchisit.org/wp-content/uploads/2011/01/oil-change.jpg\" }}",
+            ["content-type"] = "application/json"
+        };
+
+        result = await plugin["updateRepair"].InvokeAsync(kernel, arguments);
+        Console.WriteLine(result.ToString());
+
+        // Delete Repair
+        arguments = new KernelArguments
+        {
+            ["payload"] = $"{{ \"id\": {id} }}",
+            ["content-type"] = "application/json"
+        };
+
+        result = await plugin["deleteRepair"].InvokeAsync(kernel, arguments);
+        Console.WriteLine(result.ToString());
+
+        // Output:
+        // Registering Rest function RepairService.listRepairs
+        // Created KernelFunction 'listRepairs' for '<CreateRestApiFunction>g__ExecuteAsync|0'
+        // Registering Rest function RepairService.createRepair
+        // Created KernelFunction 'createRepair' for '<CreateRestApiFunction>g__ExecuteAsync|0'
+        // Registering Rest function RepairService.updateRepair
+        // Created KernelFunction 'updateRepair' for '<CreateRestApiFunction>g__ExecuteAsync|0'
+        // Registering Rest function RepairService.deleteRepair
+        // Created KernelFunction 'deleteRepair' for '<CreateRestApiFunction>g__ExecuteAsync|0'
+        // Function RepairService - createRepair invoking.
+        // Function RepairService - createRepair arguments: { "payload":"{ \u0022title\u0022: \u0022Engine oil change...
+        // Function RepairService-createRepair succeeded.
+        // Function RepairService-createRepair result: { "Content":"New repair created",...
+        // Function RepairService-createRepair completed. Duration: 0.2793481s
+        // New repair created
+        // Function RepairService-listRepairs invoking.
+        // Function RepairService-listRepairs arguments: { "payload":"{ \u0022title\u0022: \u0022Engine oil change...
+        // Function RepairService-listRepairs succeeded.
+        // Function RepairService-listRepairs result: { "Content":"[{\u0022id\u0022:79,\u0022title...
+        // Function RepairService - updateRepair invoking.
+        // Function RepairService-updateRepair arguments: { "payload":"{ \u0022id\u0022: 96, ...
+        // Function RepairService-updateRepair succeeded.
+        // Function RepairService-updateRepair result: { "Content":"Repair updated",...
+        // Function RepairService-updateRepair completed. Duration: 0.0430169s
+        // Repair updated
+        // Function RepairService - deleteRepair invoking.
+        // Function RepairService-deleteRepair arguments: { "payload":"{ \u0022id\u0022: 96 ...
+        // Function RepairService-deleteRepair succeeded.
+        // Function RepairService-deleteRepair result: { "Content":"Repair deleted",...
+        // Function RepairService-deleteRepair completed. Duration: 0.049715s
+        // Repair deleted
+    }
+
+    private sealed class Repair
+    {
+        [JsonPropertyName("id")]
+        public int? Id { get; set; }
+
+        [JsonPropertyName("title")]
+        public string? Title { get; set; }
+
+        [JsonPropertyName("description")]
+        public string? Description { get; set; }
+
+        [JsonPropertyName("assignedTo")]
+        public string? AssignedTo { get; set; }
+
+        [JsonPropertyName("date")]
+        public string? Date { get; set; }
+
+        [JsonPropertyName("image")]
+        public string? Image { get; set; }
+    }
+}

dotnet/samples/Demos/CreateChatGptPlugin/Solution/Program.cs

@@ -3,7 +3,6 @@
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.ChatCompletion;
 using Microsoft.SemanticKernel.Connectors.OpenAI;
-using Microsoft.SemanticKernel.Plugins.OpenApi;
 
 // Create kernel
 var builder = Kernel.CreateBuilder();

dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Contracts/ProcessStartRequest.cs

@@ -17,5 +17,5 @@ public record ProcessStartRequest
     /// <summary>
     /// The initial event to send to the process.
     /// </summary>
-    public required KernelProcessEvent InitialEvent { get; set; }
+    public required string InitialEvent { get; set; }
 }

dotnet/src/Experimental/Process.IntegrationTestHost.Dapr/Controllers/ProcessTestController.cs

@@ -4,6 +4,7 @@
 using Dapr.Actors.Client;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Process.Serialization;
 
 namespace SemanticKernel.Process.IntegrationTests.Controllers;
 
@@ -41,14 +42,10 @@ public async Task<IActionResult> StartProcessAsync(string processId, [FromBody]
             return this.BadRequest("Process already started");
         }
 
-        if (request.InitialEvent?.Data is JsonElement jsonElement)
-        {
-            object? data = jsonElement.Deserialize<string>();
-            request.InitialEvent = request.InitialEvent with { Data = data };
-        }
+        var initialEvent = KernelProcessEventSerializer.ToKernelProcessEvent(request.InitialEvent);
 
         var kernelProcess = request.Process.ToKernelProcess();
-        var context = await kernelProcess.StartAsync(request.InitialEvent!);
+        var context = await kernelProcess.StartAsync(initialEvent);
         s_processes.Add(processId, context);
 
         return this.Ok();

dotnet/src/Experimental/Process.IntegrationTestRunner.Dapr/DaprTestProcessContext.cs

@@ -4,6 +4,7 @@
 using System.Text.Json;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Process;
+using Microsoft.SemanticKernel.Process.Serialization;
 
 namespace SemanticKernel.Process.IntegrationTests;
 internal sealed class DaprTestProcessContext : KernelProcessContext
@@ -39,7 +40,7 @@ internal DaprTestProcessContext(KernelProcess process, HttpClient httpClient)
     internal async Task StartWithEventAsync(KernelProcessEvent initialEvent)
     {
         var daprProcess = DaprProcessInfo.FromKernelProcess(this._process);
-        var request = new ProcessStartRequest { Process = daprProcess, InitialEvent = initialEvent };
+        var request = new ProcessStartRequest { Process = daprProcess, InitialEvent = initialEvent.ToJson() };
 
         var response = await this._httpClient.PostAsJsonAsync($"http://localhost:5200/processes/{this._processId}", request, options: this._serializerOptions).ConfigureAwait(false);
         if (!response.IsSuccessStatusCode)

dotnet/src/Experimental/Process.IntegrationTests.Resources/ProcessCycleTestResources.cs

@@ -202,6 +202,60 @@ await context.EmitEventAsync(new()
     }
 }
 
+/// <summary>
+/// A step that conditionally throws an exception.
+/// </summary>
+public sealed class ErrorStep : KernelProcessStep<StepState>
+{
+    private StepState? _state;
+
+    public override ValueTask ActivateAsync(KernelProcessStepState<StepState> state)
+    {
+        this._state = state.State;
+        return default;
+    }
+
+    [KernelFunction]
+    public async Task ErrorWhenTrueAsync(KernelProcessStepContext context, bool shouldError)
+    {
+        this._state!.InvocationCount++;
+
+        if (shouldError)
+        {
+            throw new InvalidOperationException("This is an error");
+        }
+
+        await context.EmitEventAsync(new()
+        {
+            Id = ProcessTestsEvents.ErrorStepSuccess,
+            Data = null,
+            Visibility = KernelProcessEventVisibility.Internal
+        });
+    }
+}
+
+/// <summary>
+/// A step that reports an error sent to it by logging it to the console.
+/// </summary>
+public sealed class ReportStep : KernelProcessStep<StepState>
+{
+    private StepState? _state;
+
+    public override ValueTask ActivateAsync(KernelProcessStepState<StepState> state)
+    {
+        this._state = state.State;
+        return default;
+    }
+
+    [KernelFunction]
+    public Task ReportError(KernelProcessStepContext context, object error)
+    {
+        this._state!.InvocationCount++;
+        Console.WriteLine(error.ToString());
+        return Task.CompletedTask;
+    }
+}
+
 /// <summary>
 /// The state object for the repeat and fanIn step.
 /// </summary>
@@ -210,6 +264,9 @@ public sealed record StepState
 {
     [DataMember]
     public string? LastMessage { get; set; }
+
+    [DataMember]
+    public int InvocationCount { get; set; }
 }
 
 /// <summary>
@@ -222,6 +279,7 @@ public static class ProcessTestsEvents
     public const string StartInnerProcess = "StartInnerProcess";
     public const string OutputReadyPublic = "OutputReadyPublic";
     public const string OutputReadyInternal = "OutputReadyInternal";
+    public const string ErrorStepSuccess = "ErrorStepSuccess";
 }
 
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member

dotnet/src/Experimental/Process.IntegrationTests.Shared/ProcessTests.cs

@@ -217,6 +217,32 @@ public async Task FanInProcessAsync()
         Assert.Equal($"{testInput}-{testInput} {testInput}", outputStep.State.LastMessage);
     }
 
+    /// <summary>
+    /// Test with a process that has an error step that emits an error event
+    /// </summary>
+    /// <returns></returns>
+    [Fact]
+    public async Task ProcessWithErrorEmitsErrorEventAsync()
+    {
+        // Arrange
+        Kernel kernel = this._kernelBuilder.Build();
+        var process = this.CreateProcessWithError("ProcessWithError").Build();
+
+        // Act
+        bool shouldError = true;
+        var processHandle = await this._fixture.StartProcessAsync(process, kernel, new() { Id = ProcessTestsEvents.StartProcess, Data = shouldError });
+        var processInfo = await processHandle.GetStateAsync();
+
+        // Assert
+        var reportStep = processInfo.Steps.Where(s => s.State.Name == nameof(ReportStep)).FirstOrDefault()?.State as KernelProcessStepState<StepState>;
+        Assert.NotNull(reportStep?.State);
+        Assert.Equal(1, reportStep.State.InvocationCount);
+
+        var repeatStep = processInfo.Steps.Where(s => s.State.Name == nameof(RepeatStep)).FirstOrDefault()?.State as KernelProcessStepState<StepState>;
+        Assert.NotNull(repeatStep?.State);
+        Assert.Null(repeatStep.State.LastMessage);
+    }
+
     /// <summary>
     /// Test with a single step that then connects to a nested fan in process with 2 input steps
     /// </summary>
@@ -280,4 +306,18 @@ private ProcessBuilder CreateFanInProcess(string name)
 
         return processBuilder;
     }
+
+    private ProcessBuilder CreateProcessWithError(string name)
+    {
+        var processBuilder = new ProcessBuilder(name);
+        var errorStep = processBuilder.AddStepFromType<ErrorStep>("ErrorStep");
+        var repeatStep = processBuilder.AddStepFromType<RepeatStep>("RepeatStep");
+        var reportStep = processBuilder.AddStepFromType<ReportStep>("ReportStep");
+
+        processBuilder.OnInputEvent(ProcessTestsEvents.StartProcess).SendEventTo(new ProcessFunctionTargetBuilder(errorStep));
+        errorStep.OnEvent(ProcessTestsEvents.ErrorStepSuccess).SendEventTo(new ProcessFunctionTargetBuilder(repeatStep, parameterName: "message"));
+        errorStep.OnFunctionError("ErrorWhenTrue").SendEventTo(new ProcessFunctionTargetBuilder(reportStep));
+
+        return processBuilder;
+    }
 }

dotnet/src/Experimental/Process.Runtime.Dapr/Process.Runtime.Dapr.csproj

@@ -27,6 +27,8 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="SemanticKernel.Process.Runtime.Dapr.UnitTests" />
+    <InternalsVisibleTo Include="SemanticKernel.Process.IntegrationTestHost.Dapr" />
+    <InternalsVisibleTo Include="SemanticKernel.Process.IntegrationTestRunner.Dapr" />
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
   </ItemGroup>
 

dotnet/src/Functions/Functions.OpenApi/AssemblyInfo.cs

@@ -55,7 +55,7 @@ private static async Task<HttpResponseMessage> LoadDocumentResponseFromUriAsync(
             await authCallback(request, cancellationToken).ConfigureAwait(false);
         }
 
-        logger.LogTrace("Importing document from {0}", uri);
+        logger.LogTrace("Importing document from '{Uri}'", uri);
 
         return await httpClient.SendWithSuccessCheckAsync(request, cancellationToken).ConfigureAwait(false);
     }
@@ -67,9 +67,9 @@ internal static async Task<string> LoadDocumentFromFilePathAsync(
     {
         cancellationToken.ThrowIfCancellationRequested();
 
-        CheckIfFileExists(filePath);
+        CheckIfFileExists(filePath, logger);
 
-        logger.LogTrace("Importing document from {0}", filePath);
+        logger.LogTrace("Importing document from '{FilePath}'", filePath);
 
         using var sr = File.OpenText(filePath);
         return await sr.ReadToEndAsync(
@@ -79,19 +79,21 @@ internal static async Task<string> LoadDocumentFromFilePathAsync(
             ).ConfigureAwait(false);
     }
 
-    private static void CheckIfFileExists(string filePath)
+    private static void CheckIfFileExists(string filePath, ILogger logger)
     {
         if (!File.Exists(filePath))
         {
-            throw new FileNotFoundException($"Invalid URI. The specified path '{filePath}' does not exist.");
+            var exception = new FileNotFoundException($"Invalid file path. The specified path '{filePath}' does not exist.");
+            logger.LogError(exception, "Invalid file path. The specified path '{FilePath}' does not exist.", filePath);
+            throw exception;
         }
     }
 
     internal static Stream LoadDocumentFromFilePathAsStream(
         string filePath,
         ILogger logger)
     {
-        CheckIfFileExists(filePath);
+        CheckIfFileExists(filePath, logger);
 
         logger.LogTrace("Importing document from {0}", filePath);