openai 7.17.0 → 7.18.0

package/src/lib/responses/responses-websocket-session.ts

@@ -0,0 +1,317 @@
+import type { ResponsesServerEvent } from '../../resources/responses/responses';
+import type { ResponsesEmitter } from '../../resources/responses/internal-base';
+import { WebSocketError } from '../../resources/responses/internal-base';
+import { OpenAIError } from '../../core/error';
+import { ReadyState } from '../../internal/ws-adapter';
+import type { WebSocketLike } from '../../internal/ws-adapter';
+import { getWebSocketError, rawByteLength } from '../../internal/ws';
+import { hasOwn, isObj } from '../../internal/utils/values';
+import { getWebSocketEventBytes, getWebSocketEventPayload } from '../../resources/responses/ws-base';
+import {
+  getWebSocketEventBytes as getBetaWebSocketEventBytes,
+  getWebSocketEventPayload as getBetaWebSocketEventPayload,
+} from '../../resources/beta/responses/ws-base';
+import { ResponsesWebSocketLane, positiveInteger } from './responses-websocket-lane';
+
+export { ResponsesWebSocketLane } from './responses-websocket-lane';
+export type { ResponsesWebSocketEvent } from './responses-websocket-lane';
+
+interface LaneState {
+  lane: ResponsesWebSocketLane;
+  events: number;
+  bytes: number;
+}
+
+/** Limits for this optional helper. They do not change the underlying socket's limits. */
+export interface ResponsesWebSocketSessionOptions {
+  /** Maximum lane IDs registered until the next reconnect, including detached lanes. */
+  maxLanes: number;
+  /** Maximum queued events across all lanes. */
+  maxBufferedEvents: number;
+  /** Maximum queued UTF-8 JSON bytes across all lanes. */
+  maxBufferedBytes: number;
+}
+
+function parseEvent(serialized: string): ResponsesServerEvent {
+  // SAFETY: Validate the envelope below, as the native transport does for server-defined payloads.
+  const event = JSON.parse(serialized) as ResponsesServerEvent;
+  if (
+    !isObj(event) ||
+    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- Match the native event envelope at this untyped boundary.
+    typeof Object.getOwnPropertyDescriptor(event, 'type')?.value !== 'string'
+  ) {
+    throw new OpenAIError('Invalid WebSocket event shape');
+  }
+  return event;
+}
+
+function serializeCustomEvent(incoming: ResponsesServerEvent): string {
+  const snapshot = structuredClone(incoming);
+  // Mask inherited serialization hooks throughout our copy, not the caller's event.
+  const pending: unknown[] = [snapshot];
+  const visited = new Set<object>();
+  while (pending.length > 0) {
+    const value = pending.pop();
+    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- Traverse only objects in the untyped structured clone.
+    if (value === null || typeof value !== 'object' || visited.has(value)) {
+      continue;
+    }
+    visited.add(value);
+    // Keep Date's standard JSON conversion, which is owned by Date.prototype.
+    if (!(value instanceof Date) && !hasOwn(value, 'toJSON')) {
+      Object.defineProperty(value, 'toJSON', { value: undefined });
+    }
+    for (const child of Object.values(value)) {
+      pending.push(child);
+    }
+  }
+  return JSON.stringify(snapshot);
+}
+
+/**
+ * Routes events from an existing Responses socket without creating another reader.
+ * Register lanes before sending. Unregistered events remain observable on the socket.
+ * Closing this helper releases its listeners and lanes, but leaves the socket open.
+ * Attaching to a closing or closed socket is rejected.
+ * Reconnecting invalidates lanes: register new ones after restoring application state.
+ * No request is replayed by this helper.
+ */
+export class ResponsesWebSocketSession {
+  readonly #connection: ResponsesEmitter & { readonly socket: WebSocketLike };
+  readonly #lanes = new Map<string | undefined, LaneState>();
+  readonly #maxLanes: number;
+  readonly #maxEvents: number;
+  readonly #maxBytes: number;
+  #events = 0;
+  #bytes = 0;
+  #closed = false;
+  #socket: WebSocketLike | undefined;
+  #failedTransport: { socket: WebSocketLike | undefined; error: WebSocketError } | undefined;
+
+  constructor(
+    connection: ResponsesEmitter & { readonly socket: WebSocketLike },
+    options: ResponsesWebSocketSessionOptions,
+  ) {
+    this.#connection = connection;
+    this.#maxLanes = positiveInteger(options.maxLanes);
+    this.#maxEvents = positiveInteger(options.maxBufferedEvents);
+    this.#maxBytes = positiveInteger(options.maxBufferedBytes);
+    if (
+      connection.socket.readyState === ReadyState.CLOSING ||
+      connection.socket.readyState === ReadyState.CLOSED
+    ) {
+      throw new OpenAIError('Cannot attach a Responses WebSocket session to a closing or closed socket');
+    }
+    connection.on('event', this.#onEvent);
+    connection.on('error', this.#onError);
+    connection.on('close', this.#onClose);
+    connection.on('reconnecting', this.#onReconnect);
+    connection.on('reconnected', this.#onReconnected);
+    this.#onReconnected();
+  }
+
+  /** Omit streamID for the protocol's default lane. A lane has one consumer.
+   * IDs remain reserved until reconnect, including after close or failure:
+   * a terminal response can still be followed by an automatic successor.
+   */
+  lane(
+    streamID?: string,
+    limits: { maxBufferedEvents?: number; maxBufferedBytes?: number } = {},
+  ): ResponsesWebSocketLane {
+    if (this.#closed) {
+      throw new OpenAIError('Responses WebSocket session is closed');
+    }
+    this.#assertTransportAvailable(this.#connection.socket);
+    if (
+      streamID !== undefined &&
+      // oxlint-disable-next-line anti-slop/no-runtime-typeof -- Untyped JavaScript callers must not create non-string routing keys through RegExp coercion.
+      (typeof streamID !== 'string' || !/^[A-Za-z0-9_.-]{1,256}$/u.test(streamID))
+    ) {
+      throw new OpenAIError('Invalid Responses WebSocket stream ID');
+    }
+    if (this.#lanes.has(streamID)) {
+      throw new OpenAIError('Responses WebSocket lane is already registered');
+    }
+    if (this.#lanes.size >= this.#maxLanes) {
+      throw new OpenAIError('Responses WebSocket lane limit exceeded');
+    }
+    const entry: LaneState = {
+      events: 0,
+      bytes: 0,
+      lane: new ResponsesWebSocketLane(
+        streamID,
+        (event) => {
+          const { socket } = this.#connection;
+          this.#assertTransportAvailable(socket);
+          if (socket.readyState !== ReadyState.OPEN) {
+            throw new OpenAIError('Wait for an open Responses WebSocket before sending');
+          }
+          // The emitter's reconnect queue may replay an uncertain write. Send
+          // directly to the physical socket, including during its open callback.
+          socket.send(JSON.stringify(event));
+        },
+        (bytes) => {
+          this.#events -= 1;
+          this.#bytes -= bytes;
+          entry.events -= 1;
+          entry.bytes -= bytes;
+        },
+        positiveInteger(limits.maxBufferedEvents ?? this.#maxEvents),
+        positiveInteger(limits.maxBufferedBytes ?? this.#maxBytes),
+      ),
+    };
+    this.#lanes.set(streamID, entry);
+    return entry.lane;
+  }
+
+  close(): void {
+    this.#closed = true;
+    this.#removeListeners();
+    this.#failLanes(new OpenAIError('Responses WebSocket session is closed'));
+    this.#lanes.clear();
+  }
+
+  #removeListeners(): void {
+    this.#connection.off('event', this.#onEvent);
+    this.#connection.off('error', this.#onError);
+    this.#connection.off('close', this.#onClose);
+    this.#connection.off('reconnecting', this.#onReconnect);
+    this.#connection.off('reconnected', this.#onReconnected);
+    this.#socket?.off('error', this.#onSocketError);
+    this.#socket = undefined;
+  }
+
+  #onEvent = (incoming: ResponsesServerEvent): void => {
+    let event: ResponsesServerEvent;
+    let bytes: number;
+    try {
+      const payload = getWebSocketEventPayload(incoming) ?? getBetaWebSocketEventPayload(incoming);
+      // Native events are copied from the wire, before any observer's mutations.
+      // Clone custom inputs once to strip prototypes and evaluate accessors,
+      // then retain only the JSON representation covered by byte accounting.
+      let serialized = payload;
+      if (serialized === undefined) {
+        serialized = serializeCustomEvent(incoming);
+      }
+      event = parseEvent(serialized);
+      bytes =
+        payload === undefined
+          ? rawByteLength(serialized)
+          : (getBetaWebSocketEventBytes(incoming) ?? getWebSocketEventBytes(incoming));
+    } catch {
+      this.#failLanes(new OpenAIError('Cannot snapshot custom WebSocket event'));
+      return;
+    }
+    const routing = Object.getOwnPropertyDescriptor(event, 'stream_id');
+    let streamID: string | undefined;
+    if (routing) {
+      const value: unknown = routing.value;
+      // oxlint-disable-next-line anti-slop/no-runtime-typeof -- Raw event observers may mutate routing; only an own string value can select a lane, without invoking accessors.
+      if (typeof value !== 'string') {
+        return;
+      }
+      streamID = value;
+    }
+    const entry = this.#lanes.get(streamID);
+    if (!entry || entry.lane.ended) {
+      return;
+    }
+    if (bytes > this.#maxBytes) {
+      entry.lane.fail(new OpenAIError('Responses WebSocket helper buffer limit exceeded'));
+      return;
+    }
+    this.#events += 1;
+    this.#bytes += bytes;
+    entry.events += 1;
+    entry.bytes += bytes;
+    // Apply the lane's own limits first, releasing its backlog on overflow.
+    entry.lane.push(event, bytes);
+    while (this.#events > this.#maxEvents || this.#bytes > this.#maxBytes) {
+      const bytePressure = this.#bytes > this.#maxBytes;
+      let largest = entry;
+      let largestSize = 0;
+      for (const candidate of this.#lanes.values()) {
+        // Attribute pressure to existing backlogs, excluding the incoming event.
+        const size = bytePressure
+          ? candidate.bytes - (candidate === entry ? bytes : 0)
+          : candidate.events - (candidate === entry ? 1 : 0);
+        // Strict comparison breaks ties by lane registration order.
+        if (size > largestSize) {
+          largest = candidate;
+          largestSize = size;
+        }
+      }
+      largest.lane.fail(new OpenAIError('Responses WebSocket helper buffer limit exceeded'));
+    }
+  };
+
+  #onClose = (): void => {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    this.#removeListeners();
+    for (const { lane } of this.#lanes.values()) {
+      lane.end(new OpenAIError('Responses WebSocket connection closed'));
+    }
+  };
+  // oxlint-disable-next-line eslint/class-methods-use-this -- Each session owns a distinct listener so detaching one does not unhandle another session's errors.
+  #onError = (): void => {
+    // API errors are routed as events. Other emitter errors may be recoverable
+    // diagnostics; only the physical socket's errors end all lanes.
+  };
+  #onSocketError = (cause: Error): void => {
+    const error = new WebSocketError(cause.message, null);
+    Object.assign(error, { cause });
+    this.#failedTransport = { socket: this.#socket, error };
+    for (const { lane } of this.#lanes.values()) {
+      lane.end(error);
+    }
+  };
+  #onReconnect = (): void => {
+    this.#socket?.off('error', this.#onSocketError);
+    this.#socket = undefined;
+    this.#failLanes(new OpenAIError('Responses WebSocket reconnected state must be restored explicitly'));
+    this.#lanes.clear();
+  };
+  #onReconnected = (): void => {
+    if (this.#closed) {
+      return;
+    }
+    this.#socket?.off('error', this.#onSocketError);
+    this.#socket = this.#connection.socket;
+    this.#clearRecoveredTransportError(this.#socket);
+    this.#socket.on('error', this.#onSocketError);
+  };
+
+  #assertTransportAvailable(socket: WebSocketLike): void {
+    // Native transports record failure before forwarding their public error event.
+    const cause = getWebSocketError(socket);
+    if (cause) {
+      const error = new WebSocketError(cause.message, null);
+      Object.assign(error, { cause });
+      throw error;
+    }
+    this.#clearRecoveredTransportError(socket);
+    if (this.#failedTransport) {
+      throw this.#failedTransport.error;
+    }
+  }
+
+  #clearRecoveredTransportError(socket: WebSocketLike): void {
+    // Application recovery callbacks can run before our reconnected listener.
+    if (
+      this.#failedTransport &&
+      socket !== this.#failedTransport.socket &&
+      socket.readyState === ReadyState.OPEN
+    ) {
+      this.#failedTransport = undefined;
+    }
+  }
+
+  #failLanes(error: Error): void {
+    for (const { lane } of this.#lanes.values()) {
+      lane.fail(error);
+    }
+  }
+}

package/src/resources/beta/agents/sessions/sessions.ts

@@ -100,7 +100,8 @@ export class Sessions extends APIResource {
   }
 
   /**
-   * Updates session metadata. Omitted fields are unchanged. See
+   * Updates session metadata, model, reasoning effort, or service tier. Model
+   * settings apply to subsequent turns. Omitted fields are unchanged. See
    * [managing sessions](https://developers.openai.com/api/docs/guides/agents-api/sessions/manage).
    *
    * @example
@@ -277,6 +278,11 @@ export interface SessionCreateParamsStreaming extends SessionCreateParamsBase {
 }
 
 export interface SessionUpdateParams {
+  /**
+   * Model settings for subsequent turns. Omitted fields stay unchanged.
+   */
+  agent?: SessionUpdateParams.Agent;
+
   /**
    * Replaces all metadata. Omit to leave unchanged, or pass null or {} to clear it.
    * Up to 16 string key-value pairs, with keys up to 64 and values up to 512
@@ -285,6 +291,46 @@ export interface SessionUpdateParams {
   metadata?: { [key: string]: string } | null;
 }
 
+export namespace SessionUpdateParams {
+  /**
+   * Model settings for subsequent turns. Omitted fields stay unchanged.
+   */
+  export interface Agent {
+    /**
+     * The model for subsequent turns. Omit to keep the current model.
+     */
+    model?: string;
+
+    /**
+     * Reasoning settings to update. Omit to keep the current effort.
+     */
+    reasoning?: Agent.Reasoning;
+
+    /**
+     * The service tier used for model requests.
+     *
+     * - `auto` - Selects the service tier automatically.
+     * - `default` - Uses the default service tier.
+     * - `flex` - Uses the flex service tier.
+     * - `priority` - Uses the priority service tier.
+     * - `fast` - Uses the fast service tier.
+     */
+    service_tier?: 'auto' | 'default' | 'flex' | 'priority' | 'fast' | null;
+  }
+
+  export namespace Agent {
+    /**
+     * Reasoning settings to update. Omit to keep the current effort.
+     */
+    export interface Reasoning {
+      /**
+       * The amount of reasoning effort the model should use.
+       */
+      effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;
+    }
+  }
+}
+
 export interface SessionListParams extends CursorPageParams {
   /**
    * Only return sessions whose root agent has this ID. Omit to return sessions for

package/src/resources/beta/responses/responses.ts

@@ -1163,7 +1163,6 @@ export interface BetaResponse {
     | 'gpt-5.1'
     | 'gpt-5.1-2025-11-13'
     | 'gpt-5.1-codex'
-    | 'gpt-5.1-mini'
     | 'gpt-5.1-chat-latest'
     | 'gpt-5'
     | 'gpt-5-mini'
@@ -1194,6 +1193,8 @@ export interface BetaResponse {
     | 'gpt-4o-2024-11-20'
     | 'gpt-4o-2024-08-06'
     | 'gpt-4o-2024-05-13'
+    | 'gpt-audio-mini'
+    | 'gpt-audio-mini-2025-12-15'
     | 'gpt-4o-audio-preview'
     | 'gpt-4o-audio-preview-2024-10-01'
     | 'gpt-4o-audio-preview-2024-12-17'
@@ -1227,6 +1228,7 @@ export interface BetaResponse {
     | 'gpt-3.5-turbo-1106'
     | 'gpt-3.5-turbo-0125'
     | 'gpt-3.5-turbo-16k-0613'
+    | 'gpt-5.1-mini'
     | 'o1-pro'
     | 'o1-pro-2025-03-19'
     | 'o3-pro'
@@ -11740,7 +11742,6 @@ export namespace BetaResponsesClientEvent {
       | 'gpt-5.1'
       | 'gpt-5.1-2025-11-13'
       | 'gpt-5.1-codex'
-      | 'gpt-5.1-mini'
       | 'gpt-5.1-chat-latest'
       | 'gpt-5'
       | 'gpt-5-mini'
@@ -11771,6 +11772,8 @@ export namespace BetaResponsesClientEvent {
       | 'gpt-4o-2024-11-20'
       | 'gpt-4o-2024-08-06'
       | 'gpt-4o-2024-05-13'
+      | 'gpt-audio-mini'
+      | 'gpt-audio-mini-2025-12-15'
       | 'gpt-4o-audio-preview'
       | 'gpt-4o-audio-preview-2024-10-01'
       | 'gpt-4o-audio-preview-2024-12-17'
@@ -11804,6 +11807,7 @@ export namespace BetaResponsesClientEvent {
       | 'gpt-3.5-turbo-1106'
       | 'gpt-3.5-turbo-0125'
       | 'gpt-3.5-turbo-16k-0613'
+      | 'gpt-5.1-mini'
       | 'o1-pro'
       | 'o1-pro-2025-03-19'
       | 'o3-pro'
@@ -12178,6 +12182,12 @@ export namespace BetaResponsesClientEvent {
        */
       mode?: 'implicit' | 'explicit';
 
+      /**
+       * Prepares the prompt cache without generating output. Defaults to `false`. When
+       * set to `true`, overrides the `generate` field to `false`.
+       */
+      prewarm?: boolean;
+
       /**
        * The minimum lifetime applied to every implicit and explicit cache breakpoint
        * written by the request. Defaults to `30m`, which is currently the only supported
@@ -13983,7 +13993,6 @@ export interface ResponseCreateParamsBase {
     | 'gpt-5.1'
     | 'gpt-5.1-2025-11-13'
     | 'gpt-5.1-codex'
-    | 'gpt-5.1-mini'
     | 'gpt-5.1-chat-latest'
     | 'gpt-5'
     | 'gpt-5-mini'
@@ -14014,6 +14023,8 @@ export interface ResponseCreateParamsBase {
     | 'gpt-4o-2024-11-20'
     | 'gpt-4o-2024-08-06'
     | 'gpt-4o-2024-05-13'
+    | 'gpt-audio-mini'
+    | 'gpt-audio-mini-2025-12-15'
     | 'gpt-4o-audio-preview'
     | 'gpt-4o-audio-preview-2024-10-01'
     | 'gpt-4o-audio-preview-2024-12-17'
@@ -14047,6 +14058,7 @@ export interface ResponseCreateParamsBase {
     | 'gpt-3.5-turbo-1106'
     | 'gpt-3.5-turbo-0125'
     | 'gpt-3.5-turbo-16k-0613'
+    | 'gpt-5.1-mini'
     | 'o1-pro'
     | 'o1-pro-2025-03-19'
     | 'o3-pro'
@@ -14422,6 +14434,12 @@ export namespace ResponseCreateParams {
      */
     mode?: 'implicit' | 'explicit';
 
+    /**
+     * Prepares the prompt cache without generating output. Defaults to `false`. When
+     * set to `true`, overrides the `generate` field to `false`.
+     */
+    prewarm?: boolean;
+
     /**
      * The minimum lifetime applied to every implicit and explicit cache breakpoint
      * written by the request. Defaults to `30m`, which is currently the only supported
@@ -14645,7 +14663,6 @@ export interface ResponseCompactParams {
     | 'gpt-5.1'
     | 'gpt-5.1-2025-11-13'
     | 'gpt-5.1-codex'
-    | 'gpt-5.1-mini'
     | 'gpt-5.1-chat-latest'
     | 'gpt-5'
     | 'gpt-5-mini'
@@ -14676,6 +14693,8 @@ export interface ResponseCompactParams {
     | 'gpt-4o-2024-11-20'
     | 'gpt-4o-2024-08-06'
     | 'gpt-4o-2024-05-13'
+    | 'gpt-audio-mini'
+    | 'gpt-audio-mini-2025-12-15'
     | 'gpt-4o-audio-preview'
     | 'gpt-4o-audio-preview-2024-10-01'
     | 'gpt-4o-audio-preview-2024-12-17'
@@ -14709,6 +14728,7 @@ export interface ResponseCompactParams {
     | 'gpt-3.5-turbo-1106'
     | 'gpt-3.5-turbo-0125'
     | 'gpt-3.5-turbo-16k-0613'
+    | 'gpt-5.1-mini'
     | 'o1-pro'
     | 'o1-pro-2025-03-19'
     | 'o3-pro'

package/src/resources/beta/responses/ws-base.ts

@@ -7,6 +7,8 @@ import { type WebSocketLike, ReadyState } from '../../../internal/ws-adapter';
 import {
   SendQueue,
   getMaxBufferedEvents,
+  recordWebSocketError,
+  rawByteLength,
   type WebSocketStreamOptions,
   flattenRawData,
   isRecoverableClose,
@@ -19,6 +21,19 @@ import * as ResponsesAPI from './responses';
 import { OpenAI } from '../../../client';
 import { OpenAIError } from '../../../core/error';
 
+const webSocketEventPayloads = new WeakMap<object, string>();
+const webSocketEventBytes = new WeakMap<object, number>();
+
+/** Original wire size, available only during synchronous event notification. @internal */
+export function getWebSocketEventBytes(event: object): number | undefined {
+  return webSocketEventBytes.get(event);
+}
+
+/** Original JSON, available only during synchronous event notification. @internal */
+export function getWebSocketEventPayload(event: object): string | undefined {
+  return webSocketEventPayloads.get(event);
+}
+
 export interface ResponsesWSReconnectOptions {
   /**
    * Called before each reconnect attempt. Return an object with
@@ -457,7 +472,14 @@ export abstract class ResponsesWSBase<TSocket extends WebSocketLike> extends Res
         return;
       }
 
-      this._emit('event', event);
+      webSocketEventBytes.set(event, rawByteLength(data));
+      webSocketEventPayloads.set(event, text);
+      try {
+        this._emit('event', event);
+      } finally {
+        webSocketEventBytes.delete(event);
+        webSocketEventPayloads.delete(event);
+      }
 
       if (event.type === 'error') {
         this._onError(event);
@@ -468,6 +490,7 @@ export abstract class ResponsesWSBase<TSocket extends WebSocketLike> extends Res
     });
 
     socket.on('error', (err: Error) => {
+      recordWebSocketError(socket, err);
       // Suppress transient errors during reconnection — the retry loop
       // already handles them and will surface a close if retries exhaust.
       if (this._isReconnecting) return;

package/src/resources/beta/responses/ws.ts

@@ -4,7 +4,6 @@ import * as WS from 'ws';
 import { NodeWebSocket } from '../../../internal/ws-adapter-node';
 import { ResponsesWSBase, type ResponsesWSBaseOptions } from './ws-base';
 import { OpenAI } from '../../../client';
-import { VERSION } from '../../../version';
 import { OpenAIError } from '../../../core/error';
 import { snapshotWebSocketCredentials } from '../../../internal/ws';
 
@@ -34,13 +33,17 @@ export class ResponsesWS extends ResponsesWSBase<NodeWebSocket> {
 
   protected _createSocket(url: URL, authHeaders: Record<string, string>): NodeWebSocket {
     const capturedAuthHeaders = { ...authHeaders };
+    const headers = new Map(Object.entries(this._client._buildWebSocketHeaders(capturedAuthHeaders)));
+    for (const [name, value] of Object.entries(this._wsOptions?.headers ?? {})) {
+      if (value === null) {
+        headers.delete(name.toLowerCase());
+      } else if (value !== undefined) {
+        headers.set(name.toLowerCase(), value);
+      }
+    }
     const socketOptions: ResponsesWSClientOptions = {
       ...this._wsOptions,
-      headers: {
-        'User-Agent': `${this._client.constructor.name}/JS ${VERSION}`,
-        ...capturedAuthHeaders,
-        ...this._wsOptions?.headers,
-      },
+      headers: Object.fromEntries(headers),
       followRedirects: false,
     };
     if (

package/src/resources/live/forks/ws.ts

@@ -4,7 +4,6 @@ import * as WS from 'ws';
 import { NodeWebSocket } from '../../../internal/ws-adapter-node';
 import { ForksWSBase, type ForksWSBaseOptions, type ForksWSParameters } from './ws-base';
 import { OpenAI } from '../../../client';
-import { VERSION } from '../../../version';
 
 export type { WebSocketStreamOptions } from '../../../internal/ws';
 
@@ -36,10 +35,10 @@ export class ForksWS extends ForksWSBase<NodeWebSocket> {
     const ws = new WS.WebSocket(url, {
       ...this._wsOptions,
       headers: {
-        'User-Agent': `${this._client.constructor.name}/JS ${VERSION}`,
-
-        ...authHeaders,
-        ...this._wsOptions?.headers,
+        ...this._client._buildWebSocketHeaders(authHeaders),
+        ...Object.fromEntries(
+          Object.entries(this._wsOptions?.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]),
+        ),
       },
       followRedirects: false,
     });

package/src/resources/live/sideband/ws.ts

@@ -4,7 +4,6 @@ import * as WS from 'ws';
 import { NodeWebSocket } from '../../../internal/ws-adapter-node';
 import { SidebandWSBase, type SidebandWSBaseOptions, type SidebandWSParameters } from './ws-base';
 import { OpenAI } from '../../../client';
-import { VERSION } from '../../../version';
 
 export type { WebSocketStreamOptions } from '../../../internal/ws';
 
@@ -36,10 +35,10 @@ export class SidebandWS extends SidebandWSBase<NodeWebSocket> {
     const ws = new WS.WebSocket(url, {
       ...this._wsOptions,
       headers: {
-        'User-Agent': `${this._client.constructor.name}/JS ${VERSION}`,
-
-        ...authHeaders,
-        ...this._wsOptions?.headers,
+        ...this._client._buildWebSocketHeaders(authHeaders),
+        ...Object.fromEntries(
+          Object.entries(this._wsOptions?.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]),
+        ),
       },
       followRedirects: false,
     });

package/src/resources/live/ws.ts

@@ -4,7 +4,6 @@ import * as WS from 'ws';
 import { NodeWebSocket } from '../../internal/ws-adapter-node';
 import { LiveWSBase, type LiveWSBaseOptions } from './ws-base';
 import { OpenAI } from '../../client';
-import { VERSION } from '../../version';
 
 export type { WebSocketStreamOptions } from '../../internal/ws';
 
@@ -32,10 +31,10 @@ export class LiveWS extends LiveWSBase<NodeWebSocket> {
     const ws = new WS.WebSocket(url, {
       ...this._wsOptions,
       headers: {
-        'User-Agent': `${this._client.constructor.name}/JS ${VERSION}`,
-
-        ...authHeaders,
-        ...this._wsOptions?.headers,
+        ...this._client._buildWebSocketHeaders(authHeaders),
+        ...Object.fromEntries(
+          Object.entries(this._wsOptions?.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]),
+        ),
       },
       followRedirects: false,
     });