OpenAI-DotNet 8.8.0 (#472)

StephenHodgson · web-flow · commit 96540eb01a4c · 2025-07-02T13:13:50.000-04:00
- Improved RealtimeSession websocket support for proxies
  - Proxy no longer handles the websocket connection directly, but instead initiates the connection to the OpenAI api directly using the ephemeral api key

## OpenAI-DotNet-Proxy 8.8.0
- Removed Websocket handling from the proxy
diff --git a/OpenAI-DotNet-Proxy/OpenAI-DotNet-Proxy.csproj b/OpenAI-DotNet-Proxy/OpenAI-DotNet-Proxy.csproj
@@ -22,8 +22,10 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SignAssembly>false</SignAssembly>
     <ImplicitUsings>false</ImplicitUsings>
-    <Version>8.7.4</Version>
+    <Version>8.8.0</Version>
     <PackageReleaseNotes>
+Version 8.8.0
+- Removed Websocket handling from the proxy
 Version 8.7.4
 - Updated proxy support for the OpenAI-DotNet package
 - Ensure we're returning the full response message body and content length to the clients
diff --git a/OpenAI-DotNet-Proxy/Proxy/EndpointRouteBuilder.cs b/OpenAI-DotNet-Proxy/Proxy/EndpointRouteBuilder.cs
@@ -13,7 +13,6 @@
 using System.Net.WebSockets;
 using System.Security.Authentication;
 using System.Text.Json;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace OpenAI.Proxy
@@ -66,8 +65,7 @@ async Task HandleRequest(HttpContext httpContext, string endpoint)
                 {
                     if (httpContext.WebSockets.IsWebSocketRequest)
                     {
-                        await ProcessWebSocketRequest(httpContext, endpoint).ConfigureAwait(false);
-                        return;
+                        throw new InvalidOperationException("Websockets not supported");
                     }
 
                     await authenticationFilter.ValidateAuthenticationAsync(httpContext.Request.Headers).ConfigureAwait(false);
@@ -87,9 +85,7 @@ async Task HandleRequest(HttpContext httpContext, string endpoint)
 
                     var uri = new Uri(string.Format(
                         client.Settings.BaseRequestUrlFormat,
-                        QueryHelpers.AddQueryString(endpoint, modifiedQuery)
-                    ));
-
+                        QueryHelpers.AddQueryString(endpoint, modifiedQuery)));
                     using var request = new HttpRequestMessage(method, uri);
                     request.Content = new StreamContent(httpContext.Request.Body);
 
@@ -129,16 +125,18 @@ async Task HandleRequest(HttpContext httpContext, string endpoint)
                 }
                 catch (AuthenticationException authenticationException)
                 {
+                    Console.WriteLine($"{nameof(AuthenticationException)}: {authenticationException.Message}");
                     httpContext.Response.StatusCode = StatusCodes.Status401Unauthorized;
                     await httpContext.Response.WriteAsync(authenticationException.Message).ConfigureAwait(false);
                 }
-                catch (WebSocketException)
+                catch (WebSocketException webEx)
                 {
-                    // ignore
+                    Console.WriteLine($"{nameof(WebSocketException)} [{webEx.WebSocketErrorCode}] {webEx.Message}");
                     throw;
                 }
                 catch (Exception e)
                 {
+                    Console.WriteLine($"{nameof(Exception)}: {e.Message}");
                     if (httpContext.Response.HasStarted) { throw; }
                     httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
                     var response = JsonSerializer.Serialize(new { error = new { e.Message, e.StackTrace } });
@@ -152,88 +150,6 @@ static async Task WriteServerStreamEventsAsync(HttpContext httpContext, Stream c
                     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 client.WebsocketHeaders)
-                {
-                    hostWebsocket.Options.SetRequestHeader(header.Key, header.Value);
-                }
-
-                var uri = new Uri(string.Format(
-                    client.Settings.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);
-            }
         }
     }
 }
diff --git a/OpenAI-DotNet-Proxy/Proxy/OpenAIProxy.cs b/OpenAI-DotNet-Proxy/Proxy/OpenAIProxy.cs
@@ -42,7 +42,6 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
             SetupServices(app.ApplicationServices);
 
             app.UseHttpsRedirection();
-            app.UseWebSockets();
             app.UseRouting();
             app.UseEndpoints(endpoints =>
             {
@@ -82,7 +81,8 @@ public static IHost CreateDefaultHost<T>(string[] args, OpenAIClient openAIClien
         /// <typeparam name="T"><see cref="IAuthenticationFilter"/> type to use to validate your custom issued tokens.</typeparam>
         /// <param name="args">Startup args.</param>
         /// <param name="openAIClient"><see cref="OpenAIClient"/> with configured <see cref="OpenAIAuthentication"/> and <see cref="OpenAISettings"/>.</param>
-        public static WebApplication CreateWebApplication<T>(string[] args, OpenAIClient openAIClient) where T : class, IAuthenticationFilter
+        /// <param name="routePrefix"></param>
+        public static WebApplication CreateWebApplication<T>(string[] args, OpenAIClient openAIClient, string routePrefix = "") where T : class, IAuthenticationFilter
         {
             var builder = WebApplication.CreateBuilder(args);
             builder.Logging.ClearProviders();
diff --git a/OpenAI-DotNet-Tests/AbstractTestFixture.cs b/OpenAI-DotNet-Tests/AbstractTestFixture.cs
@@ -6,9 +6,6 @@
 using System;
 using System.IO;
 using System.Net.Http;
-using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace OpenAI.Tests
 {
@@ -42,24 +39,7 @@ protected AbstractTestFixture()
             OpenAIClient = new OpenAIClient(auth, settings, HttpClient)
             {
                 EnableDebug = true,
-                CreateWebsocketAsync = CreateWebsocketAsync
             };
-
-            return;
-
-            async Task<WebSocket> CreateWebsocketAsync(Uri uri, CancellationToken cancellationToken)
-            {
-                var websocketClient = webApplicationFactory.Server.CreateWebSocketClient();
-                websocketClient.ConfigureRequest = request =>
-                {
-                    foreach (var (key, value) in OpenAIClient.WebsocketHeaders)
-                    {
-                        request.Headers[key] = value;
-                    }
-                };
-                var websocket = await websocketClient.ConnectAsync(uri, cancellationToken);
-                return websocket;
-            }
         }
 
         private static Uri GetBaseAddressFromLaunchSettings()
diff --git a/OpenAI-DotNet-Tests/TestFixture_00_01_Proxy.cs b/OpenAI-DotNet-Tests/TestFixture_00_01_Proxy.cs
@@ -5,10 +5,6 @@
 using System;
 using System.IO;
 using System.Net;
-using System.Net.Http;
-using System.Net.WebSockets;
-using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace OpenAI.Tests
@@ -66,72 +62,5 @@ public async Task Test_02_Client_Authenticated()
                 Console.WriteLine(model);
             }
         }
-
-        [Test]
-        public async Task Test_03_Client_Unauthenticated()
-        {
-            var settings = new OpenAISettings(domain: HttpClient.BaseAddress?.Authority);
-            var auth = new OpenAIAuthentication("sess-invalid-token");
-            var openAIClient = new OpenAIClient(auth, settings, HttpClient);
-
-            try
-            {
-                await openAIClient.ModelsEndpoint.GetModelsAsync();
-            }
-            catch (HttpRequestException httpRequestException)
-            {
-                Console.WriteLine(httpRequestException);
-                // System.Net.Http.HttpRequestException : GetModelsAsync Failed! HTTP status code: Unauthorized | Response body: User is not authorized
-                Assert.AreEqual(HttpStatusCode.Unauthorized, httpRequestException.StatusCode);
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine(e);
-            }
-        }
-
-        [Test]
-        public async Task Test_04_Client_Websocket_Authentication()
-        {
-            try
-            {
-                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-                var realtimeUri = new Uri(string.Format(OpenAIClient.Settings.BaseWebSocketUrlFormat, "echo"));
-                Console.WriteLine(realtimeUri);
-                using var websocket = await OpenAIClient.CreateWebsocketAsync.Invoke(realtimeUri, cts.Token);
-
-                if (websocket.State != WebSocketState.Open)
-                {
-                    throw new Exception($"Failed to open WebSocket connection. Current state: {websocket.State}");
-                }
-
-                var data = new byte[1024];
-                var buffer = new byte[1024 * 4];
-                var random = new Random();
-                random.NextBytes(data);
-                await websocket.SendAsync(new ArraySegment<byte>(data), WebSocketMessageType.Binary, true, cts.Token);
-                var receiveResult = await websocket.ReceiveAsync(new ArraySegment<byte>(buffer), cts.Token);
-                Assert.AreEqual(WebSocketMessageType.Binary, receiveResult.MessageType);
-                Assert.AreEqual(data.Length, receiveResult.Count);
-                var receivedData = buffer[..receiveResult.Count];
-                Assert.AreEqual(data.Length, receivedData.Length);
-                Assert.AreEqual(data, receivedData);
-                var message = $"hello world! {DateTime.UtcNow}";
-                var messageData = Encoding.UTF8.GetBytes(message);
-                await websocket.SendAsync(new ArraySegment<byte>(messageData), WebSocketMessageType.Text, true, cts.Token);
-                receiveResult = await websocket.ReceiveAsync(new ArraySegment<byte>(buffer), cts.Token);
-                Assert.AreEqual(WebSocketMessageType.Text, receiveResult.MessageType);
-                Assert.AreEqual(messageData.Length, receiveResult.Count);
-                Assert.AreEqual(messageData, buffer[..receiveResult.Count]);
-                var decodedMessage = Encoding.UTF8.GetString(buffer, 0, receiveResult.Count);
-                Assert.AreEqual(message, decodedMessage);
-                await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Test completed", cts.Token);
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine(e);
-                throw;
-            }
-        }
     }
 }
diff --git a/OpenAI-DotNet/Authentication/OpenAISettings.cs b/OpenAI-DotNet/Authentication/OpenAISettings.cs
@@ -10,7 +10,6 @@ namespace OpenAI
     /// </summary>
     public sealed class OpenAISettings
     {
-        internal const string WS = "ws://";
         internal const string WSS = "wss://";
         internal const string Http = "http://";
         internal const string Https = "https://";
@@ -74,9 +73,7 @@ public OpenAISettings(string domain, string apiVersion = DefaultOpenAIApiVersion
             DeploymentId = string.Empty;
             BaseRequest = $"/{ApiVersion}/";
             BaseRequestUrlFormat = $"{ResourceName}{BaseRequest}{{0}}";
-            BaseWebSocketUrlFormat = ResourceName.Contains(Https)
-                ? $"{WSS}{domain}{BaseRequest}{{0}}"
-                : $"{WS}{domain}{BaseRequest}{{0}}";
+            BaseWebSocketUrlFormat = $"{WSS}{OpenAIDomain}{BaseRequest}{{0}}";
             UseOAuthAuthentication = true;
         }
 
diff --git a/OpenAI-DotNet/Common/OpenAIBaseEndpoint.cs b/OpenAI-DotNet/Common/OpenAIBaseEndpoint.cs
@@ -31,17 +31,18 @@ public abstract class OpenAIBaseEndpoint
         /// </remarks>
         protected virtual bool? IsAzureDeployment => null;
 
-        /// <summary>
-        /// Indicates if the endpoint is for a WebSocket.
-        /// </summary>
-        protected virtual bool? IsWebSocketEndpoint => null;
-
         /// <summary>
         /// Gets the full formatted url for the API endpoint.
         /// </summary>
         /// <param name="endpoint">The endpoint url.</param>
         /// <param name="queryParameters">Optional, parameters to add to the endpoint.</param>
         protected string GetUrl(string endpoint = "", Dictionary<string, string> queryParameters = null)
+            => GetEndpoint(client.Settings.BaseRequestUrlFormat, endpoint, queryParameters);
+
+        protected string GetWebsocketUri(string endpoint = "", Dictionary<string, string> queryParameters = null)
+            => GetEndpoint(client.Settings.BaseWebSocketUrlFormat, endpoint, queryParameters);
+
+        private string GetEndpoint(string baseUrlFormat, string endpoint = "", Dictionary<string, string> queryParameters = null)
         {
             string route;
 
@@ -59,9 +60,6 @@ protected string GetUrl(string endpoint = "", Dictionary<string, string> queryPa
                 route = $"{Root}{endpoint}";
             }
 
-            var baseUrlFormat = IsWebSocketEndpoint == true
-                ? client.Settings.BaseWebSocketUrlFormat
-                : client.Settings.BaseRequestUrlFormat;
             var result = string.Format(baseUrlFormat, route);
 
             foreach (var defaultQueryParameter in client.Settings.DefaultQueryParameters)
diff --git a/OpenAI-DotNet/Extensions/VoiceActivityDetectionSettingsConverter.cs b/OpenAI-DotNet/Extensions/VoiceActivityDetectionSettingsConverter.cs
@@ -11,6 +11,11 @@ internal class VoiceActivityDetectionSettingsConverter : JsonConverter<IVoiceAct
     {
         public override IVoiceActivityDetectionSettings Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (reader.TokenType == JsonTokenType.Null)
+            {
+                return null;
+            }
+
             var root = JsonDocument.ParseValue(ref reader).RootElement;
             var type = root.GetProperty("type").GetString() ?? "disabled";
 
diff --git a/OpenAI-DotNet/Extensions/WebSocket.cs b/OpenAI-DotNet/Extensions/WebSocket.cs
@@ -30,7 +30,6 @@ public WebSocket(Uri uri, IReadOnlyDictionary<string, string> requestHeaders = n
             Address = uri;
             RequestHeaders = requestHeaders ?? new Dictionary<string, string>();
             SubProtocols = subProtocols ?? new List<string>();
-            CreateWebsocketAsync = (_, _) => Task.FromResult<System.Net.WebSockets.WebSocket>(new ClientWebSocket());
             RunMessageQueue();
         }
 
@@ -122,9 +121,6 @@ public void Dispose()
         public async void Connect()
             => await ConnectAsync().ConfigureAwait(false);
 
-        // used for unit testing websocket server
-        internal Func<Uri, CancellationToken, Task<System.Net.WebSockets.WebSocket>> CreateWebsocketAsync;
-
         public async Task ConnectAsync(CancellationToken cancellationToken = default)
         {
             try
@@ -141,7 +137,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
                 _lifetimeCts = new CancellationTokenSource();
                 using var cts = CancellationTokenSource.CreateLinkedTokenSource(_lifetimeCts.Token, cancellationToken);
 
-                _socket = await CreateWebsocketAsync.Invoke(Address, cts.Token).ConfigureAwait(false);
+                _socket = new ClientWebSocket();
 
                 if (_socket is ClientWebSocket clientWebSocket)
                 {
diff --git a/OpenAI-DotNet/OpenAI-DotNet.csproj b/OpenAI-DotNet/OpenAI-DotNet.csproj
@@ -29,8 +29,11 @@ More context [on Roger Pincombe's blog](https://rogerpincombe.com/openai-dotnet-
     <AssemblyOriginatorKeyFile>OpenAI-DotNet.pfx</AssemblyOriginatorKeyFile>
     <IncludeSymbols>true</IncludeSymbols>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>8.7.4</Version>
+    <Version>8.8.0</Version>
     <PackageReleaseNotes>
+Version 8.8.0
+- Improved RealtimeSession websocket support for proxies
+  - Proxy no longer handles the websocket connection directly, but instead initiates the connection to the OpenAI api directly using the ephemeral api key
 Version 8.7.4
 - Updated proxy support for the OpenAI-DotNet-Proxy package
 - Renamed OpenAIAuthentication.LoadFromEnv -&gt; OpenAIAuthentication.LoadFromEnvironment
diff --git a/OpenAI-DotNet/OpenAIClient.cs b/OpenAI-DotNet/OpenAIClient.cs
diff --git a/OpenAI-DotNet/Realtime/ClientSecret.cs b/OpenAI-DotNet/Realtime/ClientSecret.cs
diff --git a/OpenAI-DotNet/Realtime/ExpiresAfter.cs b/OpenAI-DotNet/Realtime/ExpiresAfter.cs
diff --git a/OpenAI-DotNet/Realtime/RealtimeEndpoint.cs b/OpenAI-DotNet/Realtime/RealtimeEndpoint.cs
diff --git a/OpenAI-DotNet/Realtime/SessionConfiguration.cs b/OpenAI-DotNet/Realtime/SessionConfiguration.cs

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,11 @@ internal class VoiceActivityDetectionSettingsConverter : JsonConverter<IVoiceAct`
`11`	`11`	`{`
`12`	`12`	`public override IVoiceActivityDetectionSettings Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`13`	`13`	`{`
	`14`	`+ if (reader.TokenType == JsonTokenType.Null)`
	`15`	`+ {`
	`16`	`+ return null;`
	`17`	`+ }`
	`18`	`+`
`14`	`19`	`var root = JsonDocument.ParseValue(ref reader).RootElement;`
`15`	`20`	`var type = root.GetProperty("type").GetString() ?? "disabled";`
`16`	`21`