OpenAI-DotNet 8.4.0 (#375)

- Add realtime support
- Added `o1`, `o1-mini`, `gpt-4o-mini`, and `gpt-4o-realtime`, `gpt-4o-audio` model convenience properties
- Fixed some bugs with function invocations
- Fixed `strict` for built in `FunctionAttribute` defined tools
- Fixed `FunctionAttribute` tool generated names so they aren't too long
- Refactored `Tools` and `ToolCalls`. There is more of a distinction now in `ChatResponses`
- Refactored `SpeechRequest`, and deprecated `SpeechVoice` enum in favor of new `Voice` class
- Refactored `OpenAI.Chat` to support new audio modalities and output audio

OpenAI-DotNet-Proxy/OpenAI-DotNet-Proxy.csproj

@@ -22,8 +22,10 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SignAssembly>false</SignAssembly>
     <ImplicitUsings>false</ImplicitUsings>
-    <Version>8.2.0</Version>
+    <Version>8.4.0</Version>
     <PackageReleaseNotes>
+Version 8.4.0
+- Added support for Realtime Websocket proxy forwarding
 Version 8.2.0
 - Deprecated ValidateAuthentication for ValidateAuthenticationAsync
 Version 8.1.1

OpenAI-DotNet-Proxy/Proxy/AbstractAuthenticationFilter.cs

@@ -1,17 +1,13 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using Microsoft.AspNetCore.Http;
-using System;
 using System.Threading.Tasks;
 
 namespace OpenAI.Proxy
 {
     /// <inheritdoc />
     public abstract class AbstractAuthenticationFilter : IAuthenticationFilter
     {
-        [Obsolete("Use ValidateAuthenticationAsync")]
-        public virtual void ValidateAuthentication(IHeaderDictionary request) { }
-
         /// <inheritdoc />
         public abstract Task ValidateAuthenticationAsync(IHeaderDictionary request);
     }

OpenAI-DotNet-Proxy/Proxy/EndpointRouteBuilder.cs

@@ -9,8 +9,10 @@
 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;
 using System.Threading.Tasks;
 
 namespace OpenAI.Proxy
@@ -24,6 +26,9 @@ public static class EndpointRouteBuilder
             HeaderNames.TransferEncoding,
             HeaderNames.KeepAlive,
             HeaderNames.Upgrade,
+            HeaderNames.Host,
+            HeaderNames.SecWebSocketKey,
+            HeaderNames.SecWebSocketVersion,
             "Proxy-Connection",
             "Proxy-Authenticate",
             "Proxy-Authentication-Info",
@@ -52,22 +57,25 @@ public static class EndpointRouteBuilder
         public static void MapOpenAIEndpoints(this IEndpointRouteBuilder endpoints, OpenAIClient openAIClient, IAuthenticationFilter authenticationFilter, string routePrefix = "")
         {
             endpoints.Map($"{routePrefix}{openAIClient.OpenAIClientSettings.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);
+                    if (httpContext.WebSockets.IsWebSocketRequest)
+                    {
+                        await ProcessWebSocketRequest(httpContext, endpoint).ConfigureAwait(false);
+                        return;
+                    }
 
+                    await authenticationFilter.ValidateAuthenticationAsync(httpContext.Request.Headers).ConfigureAwait(false);
                     var method = new HttpMethod(httpContext.Request.Method);
+
                     var uri = new Uri(string.Format(
-                            openAIClient.OpenAIClientSettings.BaseRequestUrlFormat,
-                            $"{endpoint}{httpContext.Request.QueryString}"
-                        ));
+                        openAIClient.OpenAIClientSettings.BaseRequestUrlFormat,
+                        $"{endpoint}{httpContext.Request.QueryString}"
+                    ));
                     using var request = new HttpRequestMessage(method, uri);
                     request.Content = new StreamContent(httpContext.Request.Body);
 
@@ -76,7 +84,7 @@ async Task HandleRequest(HttpContext httpContext, string endpoint)
                         request.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(httpContext.Request.ContentType);
                     }
 
-                    var proxyResponse = await openAIClient.Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+                    var proxyResponse = await openAIClient.Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, httpContext.RequestAborted).ConfigureAwait(false);
                     httpContext.Response.StatusCode = (int)proxyResponse.StatusCode;
 
                     foreach (var (key, value) in proxyResponse.Headers)
@@ -96,32 +104,120 @@ async Task HandleRequest(HttpContext httpContext, string endpoint)
 
                     if (httpContext.Response.ContentType.Equals(streamingContent))
                     {
-                        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 { e.Message, e.StackTrace } });
-                    await httpContext.Response.WriteAsync(response);
+                    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);
+                }
+            }
+
+            async Task ProcessWebSocketRequest(HttpContext httpContext, string endpoint)
+            {
+                using var clientWebsocket = await httpContext.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
+
+                try
+                {
+                    await authenticationFilter.ValidateAuthenticationAsync(httpContext.Request.Headers).ConfigureAwait(false);
+                }
+                catch (AuthenticationException authenticationException)
+                {
+                    var message = JsonSerializer.Serialize(new
+                    {
+                        type = "error",
+                        error = new
+                        {
+                            type = "invalid_request_error",
+                            code = "invalid_session_token",
+                            message = authenticationException.Message
+                        }
+                    });
+                    await clientWebsocket.SendAsync(System.Text.Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, httpContext.RequestAborted).ConfigureAwait(false);
+                    await clientWebsocket.CloseAsync(WebSocketCloseStatus.PolicyViolation, authenticationException.Message, httpContext.RequestAborted).ConfigureAwait(false);
+                    return;
                 }
+
+                if (endpoint.EndsWith("echo"))
+                {
+                    await EchoAsync(clientWebsocket, httpContext.RequestAborted);
+                    return;
+                }
+
+                using var hostWebsocket = new ClientWebSocket();
+
+                foreach (var header in openAIClient.WebsocketHeaders)
+                {
+                    hostWebsocket.Options.SetRequestHeader(header.Key, header.Value);
+                }
+
+                var uri = new Uri(string.Format(
+                    openAIClient.OpenAIClientSettings.BaseWebSocketUrlFormat,
+                    $"{endpoint}{httpContext.Request.QueryString}"
+                ));
+                await hostWebsocket.ConnectAsync(uri, httpContext.RequestAborted).ConfigureAwait(false);
+                var receive = ProxyWebSocketMessages(clientWebsocket, hostWebsocket, httpContext.RequestAborted);
+                var send = ProxyWebSocketMessages(hostWebsocket, clientWebsocket, httpContext.RequestAborted);
+                await Task.WhenAll(receive, send).ConfigureAwait(false);
+                return;
+
+                async Task ProxyWebSocketMessages(WebSocket fromSocket, WebSocket toSocket, CancellationToken cancellationToken)
+                {
+                    var buffer = new byte[1024 * 4];
+                    var memoryBuffer = buffer.AsMemory();
+
+                    while (fromSocket.State == WebSocketState.Open && !cancellationToken.IsCancellationRequested)
+                    {
+                        var result = await fromSocket.ReceiveAsync(memoryBuffer, cancellationToken).ConfigureAwait(false);
+
+                        if (fromSocket.CloseStatus.HasValue || result.MessageType == WebSocketMessageType.Close)
+                        {
+                            await toSocket.CloseOutputAsync(fromSocket.CloseStatus ?? WebSocketCloseStatus.NormalClosure, fromSocket.CloseStatusDescription ?? "Closing", cancellationToken).ConfigureAwait(false);
+                            break;
+                        }
+
+                        await toSocket.SendAsync(memoryBuffer[..result.Count], result.MessageType, result.EndOfMessage, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+            }
+
+            static async Task EchoAsync(WebSocket webSocket, CancellationToken cancellationToken)
+            {
+                var buffer = new byte[1024 * 4];
+                var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancellationToken);
+
+                while (!receiveResult.CloseStatus.HasValue)
+                {
+                    await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, receiveResult.Count), receiveResult.MessageType, receiveResult.EndOfMessage, cancellationToken);
+                    receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancellationToken);
+                }
+
+                await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription, cancellationToken);
             }
         }
     }

OpenAI-DotNet-Proxy/Proxy/IAuthenticationFilter.cs

@@ -1,7 +1,6 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using Microsoft.AspNetCore.Http;
-using System;
 using System.Security.Authentication;
 using System.Threading.Tasks;
 
@@ -12,9 +11,6 @@ namespace OpenAI.Proxy
     /// </summary>
     public interface IAuthenticationFilter
     {
-        [Obsolete("Use ValidateAuthenticationAsync")]
-        void ValidateAuthentication(IHeaderDictionary request);
-
         /// <summary>
         /// Checks the headers for your user issued token.
         /// If it's not valid, then throw <see cref="AuthenticationException"/>.

OpenAI-DotNet-Proxy/Proxy/OpenAIProxy.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;
 
@@ -41,6 +42,7 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
             SetupServices(app.ApplicationServices);
 
             app.UseHttpsRedirection();
+            app.UseWebSockets();
             app.UseRouting();
             app.UseEndpoints(endpoints =>
             {
@@ -62,6 +64,12 @@ public static IHost CreateDefaultHost<T>(string[] args, OpenAIClient openAIClien
                     webBuilder.UseStartup<OpenAIProxy>();
                     webBuilder.ConfigureKestrel(ConfigureKestrel);
                 })
+                .ConfigureLogging(logger =>
+                {
+                    logger.ClearProviders();
+                    logger.AddConsole();
+                    logger.SetMinimumLevel(LogLevel.Debug);
+                })
                 .ConfigureServices(services =>
                 {
                     services.AddSingleton(openAIClient);
@@ -77,6 +85,9 @@ public static IHost CreateDefaultHost<T>(string[] args, OpenAIClient openAIClien
         public static WebApplication CreateWebApplication<T>(string[] args, OpenAIClient openAIClient) 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(openAIClient);
             builder.Services.AddSingleton<IAuthenticationFilter, T>();

OpenAI-DotNet-Tests-Proxy/OpenAI-DotNet-Tests-Proxy.csproj

@@ -10,5 +10,11 @@
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenAI-DotNet-Proxy\OpenAI-DotNet-Proxy.csproj" />
+    <ProjectReference Include="..\OpenAI-DotNet\OpenAI-DotNet.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Update="Properties\launchSettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 </Project>

OpenAI-DotNet-Tests-Proxy/Program.cs

@@ -36,7 +36,8 @@ public static void Main(string[] args)
             var auth = OpenAIAuthentication.LoadFromEnv();
             var settings = new OpenAIClientSettings(/* your custom settings if using Azure OpenAI */);
             using var openAIClient = new OpenAIClient(auth, settings);
-            OpenAIProxy.CreateWebApplication<AuthenticationFilter>(args, openAIClient).Run();
+            using var app = OpenAIProxy.CreateWebApplication<AuthenticationFilter>(args, openAIClient);
+            app.Run();
         }
     }
 }

OpenAI-DotNet-Tests-Proxy/Properties/launchSettings.json

@@ -28,4 +28,4 @@
             }
         }
     }
-}
+}