ElevenLabs-DotNet 3.5.1 (#87)

- Fix some proxy support isssues.

## ElevenLabs-DotNet-Proxy 3.5.1

- Bug fixes and better logging support.

Author: StephenHodgson

ElevenLabs-DotNet-Proxy/ElevenLabs-DotNet-Proxy.csproj

@@ -20,8 +20,10 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <SignAssembly>false</SignAssembly>
-    <Version>3.0.0</Version>
+    <Version>3.5.1</Version>
     <PackageReleaseNotes>
+Version 3.5.1
+- Bug fixes and better logging support.
 Version 3.0.0
 - Renamed ElevenLabsProxyStartup to ElevenLabsProxy
 - Deprecated ValidateAuthentication

ElevenLabs-DotNet-Proxy/Proxy/ElevenLabsProxy.cs

@@ -6,6 +6,7 @@
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Threading.Tasks;
 
@@ -62,6 +63,12 @@ public static IHost CreateDefaultHost<T>(string[] args, ElevenLabsClient elevenL
                     webBuilder.UseStartup<ElevenLabsProxy>();
                     webBuilder.ConfigureKestrel(ConfigureKestrel);
                 })
+                .ConfigureLogging(logger =>
+                {
+                    logger.ClearProviders();
+                    logger.AddConsole();
+                    logger.SetMinimumLevel(LogLevel.Debug);
+                })
                 .ConfigureServices(services =>
                 {
                     services.AddSingleton(elevenLabsClient);
@@ -77,6 +84,9 @@ public static IHost CreateDefaultHost<T>(string[] args, ElevenLabsClient elevenL
         public static WebApplication CreateWebApplication<T>(string[] args, ElevenLabsClient elevenLabsClient) where T : class, IAuthenticationFilter
         {
             var builder = WebApplication.CreateBuilder(args);
+            builder.Logging.ClearProviders();
+            builder.Logging.AddConsole();
+            builder.Logging.SetMinimumLevel(LogLevel.Debug);
             builder.WebHost.ConfigureKestrel(ConfigureKestrel);
             builder.Services.AddSingleton(elevenLabsClient);
             builder.Services.AddSingleton<IAuthenticationFilter, T>();

ElevenLabs-DotNet-Proxy/Proxy/EndpointRouteBuilder.cs

@@ -3,12 +3,14 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Net.Http.Headers;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
+using System.Net.WebSockets;
 using System.Security.Authentication;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -46,42 +48,42 @@ public static class EndpointRouteBuilder
         /// Maps the <see cref="ElevenLabsClient"/> endpoints.
         /// </summary>
         /// <param name="endpoints"><see cref="IEndpointRouteBuilder"/>.</param>
-        /// <param name="elevenLabsClient"><see cref="ElevenLabsClient"/>.</param>
+        /// <param name="client"><see cref="ElevenLabsClient"/>.</param>
         /// <param name="authenticationFilter"><see cref="IAuthenticationFilter"/>.</param>
         /// <param name="routePrefix">Optional, custom route prefix. i.e. '/elevenlabs'.</param>
-        public static void MapElevenLabsEndpoints(this IEndpointRouteBuilder endpoints, ElevenLabsClient elevenLabsClient, IAuthenticationFilter authenticationFilter, string routePrefix = "")
+        public static void MapElevenLabsEndpoints(this IEndpointRouteBuilder endpoints, ElevenLabsClient client, IAuthenticationFilter authenticationFilter, string routePrefix = "")
         {
-            endpoints.Map($"{routePrefix}{elevenLabsClient.ElevenLabsClientSettings.BaseRequest}{{**endpoint}}", HandleRequest);
+            endpoints.Map($"{routePrefix}{client.Settings.BaseRequest}{{**endpoint}}", HandleRequest);
+            return;
 
             async Task HandleRequest(HttpContext httpContext, string endpoint)
             {
                 try
                 {
-#pragma warning disable CS0618 // Type or member is obsolete
-                    // ReSharper disable once MethodHasAsyncOverload
-                    authenticationFilter.ValidateAuthentication(httpContext.Request.Headers);
-#pragma warning restore CS0618 // Type or member is obsolete
-                    await authenticationFilter.ValidateAuthenticationAsync(httpContext.Request.Headers);
-
+                    await authenticationFilter.ValidateAuthenticationAsync(httpContext.Request.Headers).ConfigureAwait(false);
                     var method = new HttpMethod(httpContext.Request.Method);
-                    var uri = new Uri(string.Format(
-                            elevenLabsClient.ElevenLabsClientSettings.BaseRequestUrlFormat,
-                            $"{endpoint}{httpContext.Request.QueryString}"
-                        ));
-                    using var request = new HttpRequestMessage(method, uri);
-                    request.Content = new StreamContent(httpContext.Request.Body);
+                    var originalQuery = QueryHelpers.ParseQuery(httpContext.Request.QueryString.Value ?? "");
+                    var modifiedQuery = new Dictionary<string, string>(originalQuery.Count);
 
-                    if (httpContext.Request.Body.CanSeek)
+                    foreach (var pair in originalQuery)
                     {
-                        httpContext.Request.Body.Position = 0;
+                        modifiedQuery[pair.Key] = pair.Value.FirstOrDefault();
                     }
 
+                    var uri = new Uri(string.Format(
+                        client.Settings.BaseRequestUrlFormat,
+                        QueryHelpers.AddQueryString(endpoint, modifiedQuery)
+                    ));
+
+                    using var request = new HttpRequestMessage(method, uri);
+                    request.Content = new StreamContent(httpContext.Request.Body);
+
                     if (httpContext.Request.ContentType != null)
                     {
                         request.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(httpContext.Request.ContentType);
                     }
 
-                    var proxyResponse = await elevenLabsClient.Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+                    var proxyResponse = await client.Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, httpContext.RequestAborted).ConfigureAwait(false);
                     httpContext.Response.StatusCode = (int)proxyResponse.StatusCode;
 
                     foreach (var (key, value) in proxyResponse.Headers)
@@ -101,32 +103,37 @@ async Task HandleRequest(HttpContext httpContext, string endpoint)
 
                     if (httpContext.Response.ContentType.Equals(streamingContent))
                     {
-                        using var reader = new StreamReader(await request.Content.ReadAsStreamAsync());
-                        var stream = await proxyResponse.Content.ReadAsStreamAsync();
-                        await WriteServerStreamEventsAsync(httpContext, stream);
+                        var stream = await proxyResponse.Content.ReadAsStreamAsync().ConfigureAwait(false);
+                        await WriteServerStreamEventsAsync(httpContext, stream).ConfigureAwait(false);
                     }
                     else
                     {
-                        await proxyResponse.Content.CopyToAsync(httpContext.Response.Body);
+                        await proxyResponse.Content.CopyToAsync(httpContext.Response.Body, httpContext.RequestAborted).ConfigureAwait(false);
                     }
                 }
                 catch (AuthenticationException authenticationException)
                 {
                     httpContext.Response.StatusCode = StatusCodes.Status401Unauthorized;
-                    await httpContext.Response.WriteAsync(authenticationException.Message);
+                    await httpContext.Response.WriteAsync(authenticationException.Message).ConfigureAwait(false);
+                }
+                catch (WebSocketException)
+                {
+                    // ignore
+                    throw;
                 }
                 catch (Exception e)
                 {
+                    if (httpContext.Response.HasStarted) { throw; }
                     httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
-                    var response = JsonSerializer.Serialize(new { error = new { message = e.Message, stackTrace = e.StackTrace } });
-                    await httpContext.Response.WriteAsync(response);
+                    var response = JsonSerializer.Serialize(new { error = new { e.Message, e.StackTrace } });
+                    await httpContext.Response.WriteAsync(response).ConfigureAwait(false);
                 }
 
                 static async Task WriteServerStreamEventsAsync(HttpContext httpContext, Stream contentStream)
                 {
                     var responseStream = httpContext.Response.Body;
-                    await contentStream.CopyToAsync(responseStream, httpContext.RequestAborted);
-                    await responseStream.FlushAsync(httpContext.RequestAborted);
+                    await contentStream.CopyToAsync(responseStream, httpContext.RequestAborted).ConfigureAwait(false);
+                    await responseStream.FlushAsync(httpContext.RequestAborted).ConfigureAwait(false);
                 }
             }
         }

ElevenLabs-DotNet-Tests/TestFixture_00_Authentication.cs

@@ -112,8 +112,8 @@ public void Test_09_CustomDomainConfigurationSettings()
             var auth = new ElevenLabsAuthentication("customIssuedToken");
             var settings = new ElevenLabsClientSettings(domain: "api.your-custom-domain.com");
             var api = new ElevenLabsClient(auth, settings);
-            Console.WriteLine(api.ElevenLabsClientSettings.BaseRequest);
-            Console.WriteLine(api.ElevenLabsClientSettings.BaseRequestUrlFormat);
+            Console.WriteLine(api.Settings.BaseRequest);
+            Console.WriteLine(api.Settings.BaseRequestUrlFormat);
         }
 
         [TearDown]

ElevenLabs-DotNet/Common/ElevenLabsBaseEndPoint.cs

@@ -24,7 +24,7 @@ public abstract class ElevenLabsBaseEndPoint
         /// <param name="queryParameters">Optional, parameters to add to the endpoint.</param>
         protected string GetUrl(string endpoint = "", Dictionary<string, string> queryParameters = null)
         {
-            var result = string.Format(client.ElevenLabsClientSettings.BaseRequestUrlFormat, $"{Root}{endpoint}");
+            var result = string.Format(client.Settings.BaseRequestUrlFormat, $"{Root}{endpoint}");
 
             if (queryParameters is { Count: not 0 })
             {

ElevenLabs-DotNet/ElevenLabs-DotNet.csproj

@@ -25,8 +25,10 @@ All copyrights, trademarks, logos, and assets are the property of their respecti
     <SignAssembly>false</SignAssembly>
     <IncludeSymbols>true</IncludeSymbols>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>3.5.0</Version>
+    <Version>3.5.1</Version>
     <PackageReleaseNotes>
+Version 3.5.1
+- Fix some proxy support issues.
 Version 3.5.0
 - Added TextToSpeechRequest.ctr overload
   - Added seed property

ElevenLabs-DotNet/ElevenLabsClient.cs

@@ -39,7 +39,7 @@ public sealed class ElevenLabsClient : IDisposable
         public ElevenLabsClient(ElevenLabsAuthentication authentication = null, ElevenLabsClientSettings settings = null, HttpClient httpClient = null)
         {
             ElevenLabsAuthentication = authentication ?? ElevenLabsAuthentication.Default;
-            ElevenLabsClientSettings = settings ?? ElevenLabsClientSettings.Default;
+            Settings = settings ?? ElevenLabsClientSettings.Default;
 
             if (string.IsNullOrWhiteSpace(ElevenLabsAuthentication?.ApiKey))
             {
@@ -128,7 +128,7 @@ private void Dispose(bool disposing)
         /// </summary>
         public ElevenLabsAuthentication ElevenLabsAuthentication { get; }
 
-        internal ElevenLabsClientSettings ElevenLabsClientSettings { get; }
+        internal ElevenLabsClientSettings Settings { get; }
 
         public UserEndpoint UserEndpoint { get; }