.Net: Migrate Python code interpreter C# plugin to the lates Azure code interpreter API version (#11856)

### Motivation, Context and Description

This PR migrates the `SessionsPythonPlugin` plugin to the latest Azure
code interpreter API version - `2024-10-02-preview`. Taking into account
that the new API has breaking changes, these have influenced the public
API surface of the plugin respectively.

Additionally, this PR takes the first step to tighten the public API
surface of the plugin and its model classes by sealing the
`SessionsPythonPlugin` and `SessionsRemoteFileMetadata` classes. More
changes in this direction will follow in the next PRs.

Author: SergeyMenshykh

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

@@ -10,6 +10,10 @@
 using Azure.Identity;
 using Azure.Core;
 using System.Collections.Generic;
+using Microsoft.SemanticKernel;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.SemanticKernel.ChatCompletion;
+using Microsoft.SemanticKernel.Connectors.AzureOpenAI;
 
 namespace SemanticKernel.IntegrationTests.Plugins.Core;
 
@@ -20,21 +24,22 @@ public sealed class SessionsPythonPluginTests : IDisposable
     private readonly SessionsPythonSettings _settings;
     private readonly HttpClientFactory _httpClientFactory;
     private readonly SessionsPythonPlugin _sut;
+    private readonly IConfigurationRoot _configurationRoot;
 
     public SessionsPythonPluginTests()
     {
-        var configurationRoot = new ConfigurationBuilder()
+        this._configurationRoot = new ConfigurationBuilder()
             .AddJsonFile(path: "testsettings.json", optional: true, reloadOnChange: true)
             .AddJsonFile(path: "testsettings.development.json", optional: true, reloadOnChange: true)
             .AddEnvironmentVariables()
             .AddUserSecrets<SessionsPythonPluginTests>()
             .Build();
 
-        var _configuration = configurationRoot
+        var _spConfiguration = this._configurationRoot
             .GetSection("AzureContainerAppSessionPool")
             .Get<AzureContainerAppSessionPoolConfiguration>()!;
 
-        this._settings = new(sessionId: Guid.NewGuid().ToString(), endpoint: new Uri(_configuration.Endpoint))
+        this._settings = new(sessionId: Guid.NewGuid().ToString(), endpoint: new Uri(_spConfiguration.Endpoint))
         {
             CodeExecutionType = SessionsPythonSettings.CodeExecutionTypeSetting.Synchronous,
             CodeInputType = SessionsPythonSettings.CodeInputTypeSetting.Inline
@@ -52,10 +57,10 @@ public async Task ItShouldUploadFileAsync()
         var result = await this._sut.UploadFileAsync("test_file.txt", @"TestData\SessionsPythonPlugin\file_to_upload_1.txt");
 
         // Assert
-        Assert.Equal("test_file.txt", result.Filename);
-        Assert.Equal(322, result.Size);
-        Assert.NotNull(result.LastModifiedTime);
-        Assert.Equal("/mnt/data/test_file.txt", result.FullPath);
+        Assert.Equal("test_file.txt", result.Name);
+        Assert.Equal(322, result.SizeInBytes);
+        Assert.Equal("file", result.Type);
+        Assert.Equal("text/plain; charset=utf-8", result.ContentType);
     }
 
     [Fact(Skip = SkipReason)]
@@ -85,16 +90,16 @@ public async Task ItShouldListFilesAsync()
         Assert.Equal(2, files.Count);
 
         var firstFile = files[0];
-        Assert.Equal("test_file_1.txt", firstFile.Filename);
-        Assert.Equal(322, firstFile.Size);
-        Assert.NotNull(firstFile.LastModifiedTime);
-        Assert.Equal("/mnt/data/test_file_1.txt", firstFile.FullPath);
+        Assert.Equal("test_file_1.txt", firstFile.Name);
+        Assert.Equal(322, firstFile.SizeInBytes);
+        Assert.Equal("file", firstFile.Type);
+        Assert.Equal("text/plain; charset=utf-8", firstFile.ContentType);
 
         var secondFile = files[1];
-        Assert.Equal("test_file_2.txt", secondFile.Filename);
-        Assert.Equal(336, secondFile.Size);
-        Assert.NotNull(secondFile.LastModifiedTime);
-        Assert.Equal("/mnt/data/test_file_2.txt", secondFile.FullPath);
+        Assert.Equal("test_file_2.txt", secondFile.Name);
+        Assert.Equal(336, secondFile.SizeInBytes);
+        Assert.Equal("file", secondFile.Type);
+        Assert.Equal("text/plain; charset=utf-8", secondFile.ContentType);
     }
 
     [Fact(Skip = SkipReason)]
@@ -108,7 +113,31 @@ public async Task ItShouldExecutePythonCodeAsync()
 
         // Assert
         Assert.Contains("8", result);
-        Assert.Contains("Success", result);
+        Assert.Contains("Succeeded", result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task LlmShouldUploadFileAndAccessItFromCodeInterpreterAsync()
+    {
+        // Arrange
+        Kernel kernel = this.InitializeKernel();
+        kernel.Plugins.AddFromObject(this._sut);
+
+        var chatCompletionService = kernel.Services.GetRequiredService<IChatCompletionService>();
+
+        AzureOpenAIPromptExecutionSettings settings = new()
+        {
+            FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
+        };
+
+        ChatHistory chatHistory = [];
+        chatHistory.AddUserMessage(@"Upload the local file TestData\SessionsPythonPlugin\file_to_upload_1.txt and use python code to count number of words in it.");
+
+        // Act
+        var result = await chatCompletionService.GetChatMessageContentAsync(chatHistory, settings, kernel);
+
+        // Assert
+        Assert.Contains("52", result.ToString());
     }
 
     /// <summary>
@@ -125,6 +154,24 @@ private static async Task<string> GetAuthTokenAsync()
         return token.Token;
     }
 
+    private Kernel InitializeKernel()
+    {
+        var azureOpenAIConfiguration = this._configurationRoot.GetSection("AzureOpenAI").Get<AzureOpenAIConfiguration>();
+        Assert.NotNull(azureOpenAIConfiguration);
+        Assert.NotNull(azureOpenAIConfiguration.ChatDeploymentName);
+        Assert.NotNull(azureOpenAIConfiguration.Endpoint);
+
+        var kernelBuilder = Kernel.CreateBuilder();
+
+        kernelBuilder.AddAzureOpenAIChatCompletion(
+            deploymentName: azureOpenAIConfiguration.ChatDeploymentName,
+            modelId: azureOpenAIConfiguration.ChatModelId,
+            endpoint: azureOpenAIConfiguration.Endpoint,
+            credentials: new AzureCliCredential());
+
+        return kernelBuilder.Build();
+    }
+
     public void Dispose()
     {
         this._httpClientFactory.Dispose();

dotnet/src/Plugins/Plugins.Core/CodeInterpreter/SessionsPythonCodeExecutionProperties.cs

@@ -7,12 +7,6 @@ namespace Microsoft.SemanticKernel.Plugins.Core.CodeInterpreter;
 
 internal sealed class SessionsPythonCodeExecutionProperties
 {
-    /// <summary>
-    /// The session identifier.
-    /// </summary>
-    [JsonPropertyName("identifier")]
-    public string Identifier { get; }
-
     /// <summary>
     /// Code input type.
     /// </summary>
@@ -34,12 +28,11 @@ internal sealed class SessionsPythonCodeExecutionProperties
     /// <summary>
     /// The Python code to execute.
     /// </summary>
-    [JsonPropertyName("pythonCode")]
-    public string? PythonCode { get; }
+    [JsonPropertyName("code")]
+    public string PythonCode { get; }
 
     public SessionsPythonCodeExecutionProperties(SessionsPythonSettings settings, string pythonCode)
     {
-        this.Identifier = settings.SessionId;
         this.PythonCode = pythonCode;
         this.TimeoutInSeconds = settings.TimeoutInSeconds;
         this.CodeInputType = settings.CodeInputType;

dotnet/src/Plugins/Plugins.Core/CodeInterpreter/SessionsPythonPlugin.cs

@@ -18,10 +18,10 @@ namespace Microsoft.SemanticKernel.Plugins.Core.CodeInterpreter;
 /// <summary>
 /// A plugin for running Python code in an Azure Container Apps dynamic sessions code interpreter.
 /// </summary>
-public partial class SessionsPythonPlugin
+public sealed partial class SessionsPythonPlugin
 {
     private static readonly string s_assemblyVersion = typeof(Kernel).Assembly.GetName().Version!.ToString();
-    private const string ApiVersion = "2024-02-02-preview";
+    private const string ApiVersion = "2024-10-02-preview";
     private readonly Uri _poolManagementEndpoint;
     private readonly SessionsPythonSettings _settings;
     private readonly Func<Task<string>>? _authTokenProvider;
@@ -90,14 +90,11 @@ public async Task<string> ExecuteCodeAsync([Description("The valid Python code t
 
         using var httpClient = this._httpClientFactory.CreateClient();
 
-        var requestBody = new
-        {
-            properties = new SessionsPythonCodeExecutionProperties(this._settings, code)
-        };
+        var requestBody = new SessionsPythonCodeExecutionProperties(this._settings, code);
 
         await this.AddHeadersAsync(httpClient).ConfigureAwait(false);
 
-        using var request = new HttpRequestMessage(HttpMethod.Post, this._poolManagementEndpoint + $"python/execute?api-version={ApiVersion}")
+        using var request = new HttpRequestMessage(HttpMethod.Post, $"{this._poolManagementEndpoint}/executions?identifier={this._settings.SessionId}&api-version={ApiVersion}")
         {
             Content = new StringContent(JsonSerializer.Serialize(requestBody), Encoding.UTF8, "application/json")
         };
@@ -110,17 +107,19 @@ public async Task<string> ExecuteCodeAsync([Description("The valid Python code t
             throw new HttpRequestException($"Failed to execute python code. Status: {response.StatusCode}. Details: {errorBody}.");
         }
 
-        var jsonElementResult = JsonSerializer.Deserialize<JsonElement>(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
+        var responseContent = JsonSerializer.Deserialize<JsonElement>(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
+
+        var result = responseContent.GetProperty("result");
 
         return $"""
             Status:
-            {jsonElementResult.GetProperty("status").GetRawText()}
+            {responseContent.GetProperty("status").GetRawText()}
             Result:
-            {jsonElementResult.GetProperty("result").GetRawText()}
+            {result.GetProperty("executionResult").GetRawText()}
             Stdout:
-            {jsonElementResult.GetProperty("stdout").GetRawText()}
+            {result.GetProperty("stdout").GetRawText()}
             Stderr:
-            {jsonElementResult.GetProperty("stderr").GetRawText()}
+            {result.GetProperty("stderr").GetRawText()}
             """;
     }
 
@@ -135,33 +134,33 @@ private async Task AddHeadersAsync(HttpClient httpClient)
     }
 
     /// <summary>
-    /// Upload a file to the session pool.
+    /// Uploads a file to the `/mnt/data` directory of the current session.
     /// </summary>
-    /// <param name="remoteFilePath">The path to the file in the session.</param>
+    /// <param name="remoteFileName">The name of the remote file, relative to `/mnt/data`.</param>
     /// <param name="localFilePath">The path to the file on the local machine.</param>
     /// <returns>The metadata of the uploaded file.</returns>
     /// <exception cref="ArgumentNullException"></exception>
     /// <exception cref="HttpRequestException"></exception>
-    [KernelFunction, Description("Uploads a file for the current session id pool.")]
+    [KernelFunction, Description("Uploads a file to the `/mnt/data` directory of the current session.")]
     public async Task<SessionsRemoteFileMetadata> UploadFileAsync(
-        [Description("The path to the file in the session.")] string remoteFilePath,
-        [Description("The path to the file on the local machine.")] string? localFilePath)
+        [Description("The name of the remote file, relative to `/mnt/data`.")] string remoteFileName,
+        [Description("The path to the file on the local machine.")] string localFilePath)
     {
-        Verify.NotNullOrWhiteSpace(remoteFilePath, nameof(remoteFilePath));
+        Verify.NotNullOrWhiteSpace(remoteFileName, nameof(remoteFileName));
         Verify.NotNullOrWhiteSpace(localFilePath, nameof(localFilePath));
 
-        this._logger.LogInformation("Uploading file: {LocalFilePath} to {RemoteFilePath}", localFilePath, remoteFilePath);
+        this._logger.LogInformation("Uploading file: {LocalFilePath} to {RemoteFilePath}", localFilePath, remoteFileName);
 
         using var httpClient = this._httpClientFactory.CreateClient();
 
         await this.AddHeadersAsync(httpClient).ConfigureAwait(false);
 
         using var fileContent = new ByteArrayContent(File.ReadAllBytes(localFilePath));
-        using var request = new HttpRequestMessage(HttpMethod.Post, $"{this._poolManagementEndpoint}files/upload?identifier={this._settings.SessionId}&api-version={ApiVersion}")
+        using var request = new HttpRequestMessage(HttpMethod.Post, $"{this._poolManagementEndpoint}files?identifier={this._settings.SessionId}&api-version={ApiVersion}")
         {
             Content = new MultipartFormDataContent
             {
-                { fileContent, "file", remoteFilePath },
+                { fileContent, "file", remoteFileName },
             }
         };
 
@@ -173,30 +172,30 @@ public async Task<SessionsRemoteFileMetadata> UploadFileAsync(
             throw new HttpRequestException($"Failed to upload file. Status code: {response.StatusCode}. Details: {errorBody}.");
         }
 
-        var JsonElementResult = JsonSerializer.Deserialize<JsonElement>(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
+        var stringContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
 
-        return JsonSerializer.Deserialize<SessionsRemoteFileMetadata>(JsonElementResult.GetProperty("value")[0].GetProperty("properties").GetRawText())!;
+        return JsonSerializer.Deserialize<SessionsRemoteFileMetadata>(stringContent)!;
     }
 
     /// <summary>
-    /// Downloads a file from the current Session ID.
+    /// Downloads a file from the `/mnt/data` directory of the current session.
     /// </summary>
-    /// <param name="remoteFilePath"> The path to download the file from, relative to `/mnt/data`. </param>
-    /// <param name="localFilePath"> The path to save the downloaded file to. If not provided won't save it in the disk.</param>
-    /// <returns> The data of the downloaded file as byte array. </returns>
-    [KernelFunction, Description("Downloads a file from the current Session ID.")]
+    /// <param name="remoteFileName">The name of the remote file to download, relative to `/mnt/data`.</param>
+    /// <param name="localFilePath">The path to save the downloaded file to. If not provided won't save it in the disk.</param>
+    /// <returns>The data of the downloaded file as byte array.</returns>
+    [KernelFunction, Description("Downloads a file from the `/mnt/data` directory of the current session.")]
     public async Task<byte[]> DownloadFileAsync(
-        [Description("The path to download the file from, relative to `/mnt/data`.")] string remoteFilePath,
+        [Description("The name of the remote file to download, relative to `/mnt/data`.")] string remoteFileName,
         [Description("The path to save the downloaded file to. If not provided won't save it in the disk.")] string? localFilePath = null)
     {
-        Verify.NotNullOrWhiteSpace(remoteFilePath, nameof(remoteFilePath));
+        Verify.NotNullOrWhiteSpace(remoteFileName, nameof(remoteFileName));
 
-        this._logger.LogTrace("Downloading file: {RemoteFilePath} to {LocalFilePath}", remoteFilePath, localFilePath);
+        this._logger.LogTrace("Downloading file: {RemoteFilePath} to {LocalFilePath}", remoteFileName, localFilePath);
 
         using var httpClient = this._httpClientFactory.CreateClient();
         await this.AddHeadersAsync(httpClient).ConfigureAwait(false);
 
-        var response = await httpClient.GetAsync(new Uri($"{this._poolManagementEndpoint}python/downloadFile?identifier={this._settings.SessionId}&filename={remoteFilePath}&api-version={ApiVersion}")).ConfigureAwait(false);
+        var response = await httpClient.GetAsync(new Uri($"{this._poolManagementEndpoint}/files/{Uri.EscapeDataString(remoteFileName)}/content?identifier={this._settings.SessionId}&api-version={ApiVersion}")).ConfigureAwait(false);
         if (!response.IsSuccessStatusCode)
         {
             var errorBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
@@ -221,10 +220,10 @@ public async Task<byte[]> DownloadFileAsync(
     }
 
     /// <summary>
-    /// Lists all files in the provided session id pool.
+    /// Lists all entities: files or directories in the `/mnt/data` directory of the current session.
     /// </summary>
-    /// <returns> The list of files in the session. </returns>
-    [KernelFunction, Description("Lists all files in the provided session id pool.")]
+    /// <returns>The list of files in the session.</returns>
+    [KernelFunction, Description("Lists all entities: files or directories in the `/mnt/data` directory of the current session.")]
     public async Task<IReadOnlyList<SessionsRemoteFileMetadata>> ListFilesAsync()
     {
         this._logger.LogTrace("Listing files for Session ID: {SessionId}", this._settings.SessionId);
@@ -243,14 +242,7 @@ public async Task<IReadOnlyList<SessionsRemoteFileMetadata>> ListFilesAsync()
 
         var files = jsonElementResult.GetProperty("value");
 
-        var result = new SessionsRemoteFileMetadata[files.GetArrayLength()];
-
-        for (var i = 0; i < result.Length; i++)
-        {
-            result[i] = JsonSerializer.Deserialize<SessionsRemoteFileMetadata>(files[i].GetProperty("properties").GetRawText())!;
-        }
-
-        return result;
+        return files.Deserialize<SessionsRemoteFileMetadata[]>()!;
     }
 
     private static Uri GetBaseEndpoint(Uri endpoint)