.Net: Add AssemblyAI file service Remake from #5964

dotnet/src/Connectors/Connectors.AssemblyAI.UnitTests/AudioToText/AssemblyAIAudioToTextServiceTests.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System;
-using System.IO;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
@@ -116,38 +115,6 @@ public async Task GetTextContentByUrlWorksCorrectlyAsync()
         Assert.Equal(ExpectedTranscriptText, result[0].Text);
     }
 
-    [Fact]
-    public async Task GetTextContentByStreamWorksCorrectlyAsync()
-    {
-        // Arrange
-        var service = new AssemblyAIAudioToTextService("api-key", httpClient: this._httpClient);
-        using var uploadFileResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
-        uploadFileResponse.Content = new StringContent(UploadFileResponseContent);
-        using var transcribeResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
-        transcribeResponse.Content = new StringContent(CreateTranscriptResponseContent);
-        using var transcribedResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
-        transcribedResponse.Content = new StringContent(TranscriptCompletedResponseContent);
-        this._messageHandlerStub.ResponsesToReturn =
-        [
-            uploadFileResponse,
-            transcribeResponse,
-            transcribedResponse
-        ];
-
-        using var ms = new MemoryStream();
-
-        // Act
-        var result = await service.GetTextContentsAsync(
-            new AudioStreamContent(ms)
-        ).ConfigureAwait(true);
-
-        // Assert
-        Assert.NotNull(result);
-        Assert.NotNull(result);
-        Assert.Single(result);
-        Assert.Equal(ExpectedTranscriptText, result[0].Text);
-    }
-
     [Fact]
     public async Task HttpErrorShouldThrowWithErrorMessageAsync()
     {

dotnet/src/Connectors/Connectors.AssemblyAI.UnitTests/Connectors.AssemblyAI.UnitTests.csproj

@@ -10,7 +10,7 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>disable</ImplicitUsings>
     <IsPackable>false</IsPackable>
-    <NoWarn>SKEXP0001;SKEXP0005;SKEXP0070;CS1591</NoWarn>
+    <NoWarn>SKEXP0001;SKEXP0070;CS1591</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>

dotnet/src/Connectors/Connectors.AssemblyAI.UnitTests/Files/AssemblyAIFileServiceTests.cs

@@ -0,0 +1,121 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Connectors.AssemblyAI;
+using Microsoft.SemanticKernel.Connectors.AssemblyAI.Files;
+using SemanticKernel.Connectors.AssemblyAI.UnitTests;
+using Xunit;
+
+namespace SemanticKernel.Connectors.UnitTests.AssemblyAI;
+
+/// <summary>
+/// Unit tests for <see cref="AssemblyAIAudioToTextService"/> class.
+/// </summary>
+public sealed class AssemblyAIFileServiceTests : IDisposable
+{
+    private const string UploadedFileUrl = "http://localhost/path/to/file.mp3";
+
+    private const string UploadFileResponseContent =
+        $$"""
+          {
+              "upload_url": "{{UploadedFileUrl}}"
+          }
+          """;
+
+    private readonly MultipleHttpMessageHandlerStub _messageHandlerStub;
+    private readonly HttpClient _httpClient;
+
+    public AssemblyAIFileServiceTests()
+    {
+        this._messageHandlerStub = new MultipleHttpMessageHandlerStub();
+        this._httpClient = new HttpClient(this._messageHandlerStub, false);
+    }
+
+    [Fact]
+    public void ConstructorWithHttpClientWorksCorrectly()
+    {
+        // Arrange & Act
+        var service = new AssemblyAIAudioToTextService("api-key", httpClient: this._httpClient);
+
+        // Assert
+        Assert.NotNull(service);
+    }
+
+    [Fact]
+    public async Task UploadFileAsync()
+    {
+        // Arrange
+        var service = new AssemblyAIFileService("api-key", httpClient: this._httpClient);
+        using var uploadFileResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
+        uploadFileResponse.Content = new StringContent(UploadFileResponseContent);
+        using var transcribeResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
+        this._messageHandlerStub.ResponsesToReturn =
+        [
+            uploadFileResponse,
+        ];
+        using var stream = new BinaryData("data").ToStream();
+
+        // Act
+        var result = await service.UploadAsync(stream).ConfigureAwait(true);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Null(result.Data);
+        Assert.Equal(new Uri(UploadedFileUrl), result.Uri);
+    }
+
+    [Fact]
+    public async Task HttpErrorShouldThrowWithErrorMessageAsync()
+    {
+        // Arrange
+        var service = new AssemblyAIFileService("api-key", httpClient: this._httpClient);
+        using var uploadFileResponse = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError);
+        this._messageHandlerStub.ResponsesToReturn =
+        [
+            uploadFileResponse
+        ];
+        using var stream = new BinaryData("data").ToStream();
+        // Act & Assert
+        await Assert.ThrowsAsync<HttpOperationException>(
+            async () => await service.UploadAsync(stream).ConfigureAwait(true)
+        ).ConfigureAwait(true);
+    }
+
+    [Fact]
+    public async Task JsonErrorShouldThrowWithErrorMessageAsync()
+    {
+        // Arrange
+        var service = new AssemblyAIFileService("api-key", httpClient: this._httpClient);
+        using var uploadFileResponse = new HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized);
+        const string ErrorMessage = "Bad API key";
+        uploadFileResponse.Content = new StringContent(
+            $$"""
+              {
+                  "error": "{{ErrorMessage}}"
+              }
+              """,
+            Encoding.UTF8,
+            "application/json"
+        );
+        this._messageHandlerStub.ResponsesToReturn =
+        [
+            uploadFileResponse
+        ];
+        using var stream = new BinaryData("data").ToStream();
+
+        // Act & Assert
+        await Assert.ThrowsAsync<HttpOperationException>(
+            async () => await service.UploadAsync(stream).ConfigureAwait(true)
+        ).ConfigureAwait(true);
+    }
+
+    public void Dispose()
+    {
+        this._httpClient.Dispose();
+        this._messageHandlerStub.Dispose();
+    }
+}

dotnet/src/Connectors/Connectors.AssemblyAI.UnitTests/Files/AssemblyAIFilesExtensionsTests.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Net.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Connectors.AssemblyAI.Files;
+using Xunit;
+
+namespace SemanticKernel.Connectors.UnitTests.AssemblyAI;
+
+/// <summary>
+/// Unit tests for <see cref="AssemblyAIServiceCollectionExtensions"/> class.
+/// </summary>
+public sealed class AssemblyAIFilesExtensionsTests
+{
+    private const string ApiKey = "Test123";
+    private const string Endpoint = "http://localhost:1234/";
+    private const string ServiceId = "AssemblyAI";
+
+    [Fact]
+    public void AddServiceToKernelBuilder()
+    {
+        // Arrange & Act
+        using var httpClient = new HttpClient();
+        var kernel = Kernel.CreateBuilder()
+            .AddAssemblyAIFiles(
+                apiKey: ApiKey,
+                endpoint: new Uri(Endpoint),
+                serviceId: ServiceId,
+                httpClient: httpClient
+            )
+            .Build();
+
+        // Assert
+        var service = kernel.GetRequiredService<AssemblyAIFileService>();
+        Assert.NotNull(service);
+        Assert.IsType<AssemblyAIFileService>(service);
+
+        service = kernel.GetRequiredService<AssemblyAIFileService>(ServiceId);
+        Assert.NotNull(service);
+        Assert.IsType<AssemblyAIFileService>(service);
+    }
+
+    [Fact]
+    public void AddServiceToServiceCollection()
+    {
+        // Arrange & Act
+        var services = new ServiceCollection();
+        services.AddAssemblyAIFiles(
+            apiKey: ApiKey,
+            endpoint: new Uri(Endpoint),
+            serviceId: ServiceId
+        );
+        using var provider = services.BuildServiceProvider();
+
+        // Assert
+        var service = provider.GetRequiredKeyedService<AssemblyAIFileService>(ServiceId);
+        Assert.NotNull(service);
+        Assert.IsType<AssemblyAIFileService>(service);
+    }
+}

dotnet/src/Connectors/Connectors.AssemblyAI/AssemblyAIKernelBuilderExtensions.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.SemanticKernel.AudioToText;
 using Microsoft.SemanticKernel.Connectors.AssemblyAI;
+using Microsoft.SemanticKernel.Connectors.AssemblyAI.Files;
 
 namespace Microsoft.SemanticKernel;
 
@@ -32,12 +33,42 @@ public static IKernelBuilder AddAssemblyAIAudioToText(
     {
         Verify.NotNull(builder);
 
-        builder.Services.AddKeyedSingleton<IAudioToTextService>(serviceId, (serviceProvider, _)
+        builder.Services.AddKeyedSingleton<IAudioToTextService>(serviceId, (_, _)
             => new AssemblyAIAudioToTextService(
                 apiKey,
                 endpoint,
                 httpClient));
 
         return builder;
     }
+
+    /// <summary>
+    /// Adds the AssemblyAI file service to the kernel.
+    /// </summary>
+    /// <param name="builder">The <see cref="IKernelBuilder"/> instance to augment.</param>
+    /// <param name="apiKey">AssemblyAI API key, <a href="https://www.assemblyai.com/dashboard">get your API key from the dashboard.</a></param>
+    /// <param name="endpoint">The endpoint URL to the AssemblyAI API.</param>
+    /// <param name="serviceId">A local identifier for the given AI service.</param>
+    /// <param name="httpClient">The HttpClient to use with this service.</param>
+    /// <returns>The same instance as <paramref name="builder"/>.</returns>
+    public static IKernelBuilder AddAssemblyAIFiles(
+        this IKernelBuilder builder,
+        string apiKey,
+        Uri? endpoint = null,
+        string? serviceId = null,
+        HttpClient? httpClient = null
+    )
+    {
+        Verify.NotNull(builder);
+
+        builder.Services.AddKeyedSingleton(serviceId, (_, _) =>
+            new AssemblyAIFileService(
+                apiKey,
+                endpoint,
+                httpClient
+            )
+        );
+
+        return builder;
+    }
 }

dotnet/src/Connectors/Connectors.AssemblyAI/AssemblyAIServiceCollectionExtensions.cs

@@ -4,6 +4,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.SemanticKernel.AudioToText;
 using Microsoft.SemanticKernel.Connectors.AssemblyAI;
+using Microsoft.SemanticKernel.Connectors.AssemblyAI.Files;
 using Microsoft.SemanticKernel.Http;
 
 namespace Microsoft.SemanticKernel;
@@ -34,7 +35,35 @@ public static IServiceCollection AddAssemblyAIAudioToText(
                 apiKey,
                 endpoint,
                 HttpClientProvider.GetHttpClient(serviceProvider)
-            ));
+            )
+        );
+
+        return services;
+    }
+
+    /// <summary>
+    /// Adds the AssemblyAI file service to the list.
+    /// </summary>
+    /// <param name="services">The <see cref="IServiceCollection"/> instance to augment.</param>
+    /// <param name="apiKey">AssemblyAI API key, <a href="https://www.assemblyai.com/dashboard">get your API key from the dashboard.</a></param>
+    /// <param name="endpoint">The endpoint URL to the AssemblyAI API.</param>
+    /// <param name="serviceId">A local identifier for the given AI service.</param>
+    /// <returns>The same instance as <paramref name="services"/>.</returns>
+    public static IServiceCollection AddAssemblyAIFiles(
+        this IServiceCollection services,
+        string apiKey,
+        Uri? endpoint = null,
+        string? serviceId = null
+    )
+    {
+        Verify.NotNull(services);
+        services.AddKeyedSingleton(serviceId, (serviceProvider, _) =>
+            new AssemblyAIFileService(
+                apiKey,
+                endpoint,
+                HttpClientProvider.GetHttpClient(serviceProvider)
+            )
+        );
 
         return services;
     }

dotnet/src/Connectors/Connectors.AssemblyAI/Files/AssemblyAIFileService.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel.Connectors.AssemblyAI.Client;
+using Microsoft.SemanticKernel.Http;
+
+namespace Microsoft.SemanticKernel.Connectors.AssemblyAI.Files;
+
+/// <summary>
+/// Service to upload files to AssemblyAI
+/// </summary>
+public sealed class AssemblyAIFileService
+{
+    private readonly AssemblyAIClient _client;
+
+    /// <summary>
+    /// Creates an instance of the <see cref="AssemblyAIFileService"/> with an AssemblyAI API key.
+    /// </summary>
+    /// <param name="apiKey">AssemblyAI API key</param>
+    /// <param name="endpoint">Optional endpoint uri including the port where AssemblyAI server is hosted</param>
+    /// <param name="httpClient">Optional HTTP client to be used for communication with the AssemblyAI API.</param>
+    /// <param name="loggerFactory">Optional logger factory to be used for logging.</param>
+    public AssemblyAIFileService(
+        string apiKey,
+        Uri? endpoint = null,
+        HttpClient? httpClient = null,
+        ILoggerFactory? loggerFactory = null
+    )
+    {
+        Verify.NotNullOrWhiteSpace(apiKey);
+        this._client = new AssemblyAIClient(
+            httpClient: HttpClientProvider.GetHttpClient(httpClient),
+            endpoint: endpoint,
+            apiKey: apiKey,
+            logger: loggerFactory?.CreateLogger(this.GetType()));
+    }
+
+    /// <summary>
+    /// Upload a file.
+    /// </summary>
+    /// <param name="stream">The file stream</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The file metadata.</returns>
+    public async Task<AudioContent> UploadAsync(Stream stream, CancellationToken cancellationToken = default)
+    {
+        Verify.NotNull(stream);
+        var file = await this._client.UploadFileAsync(stream, cancellationToken).ConfigureAwait(false);
+        return new AudioContent(new Uri(file, UriKind.Absolute));
+    }
+}