openai 7.5.0 → 7.6.0

package/src/auth/subject-token-providers.ts

@@ -7,6 +7,147 @@ import { SubjectTokenProviderError } from '../core/error';
 const DEFAULT_RESOURCE = 'https://management.azure.com/';
 const DEFAULT_AZURE_API_VERSION = '2018-02-01';
 const AZURE_IMDS_BASE_URL = 'http://169.254.169.254/metadata/identity/oauth2/token';
+const MAX_AZURE_IMDS_JSON_ERROR_CAUSES = 32;
+const getOwnErrorDescriptor = Object.getOwnPropertyDescriptor;
+const getErrorPrototype = Object.getPrototypeOf;
+const errorObjectToString = Object.prototype.toString;
+const errorFunctionToString = Function.prototype.toString;
+const nativeErrorSource = errorFunctionToString.call(Error);
+const nativeSyntaxErrorSource = errorFunctionToString.call(SyntaxError);
+const nativeErrorBrandDescriptor = getOwnErrorDescriptor(Error, 'isError');
+const nativeErrorBrand =
+  nativeErrorBrandDescriptor &&
+  'value' in nativeErrorBrandDescriptor &&
+  typeof nativeErrorBrandDescriptor.value === 'function'
+    ? (nativeErrorBrandDescriptor.value as (error: object) => boolean)
+    : undefined;
+
+type AzureJSONErrorKind = 'error' | 'syntax' | 'tagged-wrapper' | 'unknown' | 'unsafe';
+
+function hasNativeErrorPrototype(prototype: object, kind: 'Error' | 'SyntaxError'): boolean {
+  const name = getOwnErrorDescriptor(prototype, 'name');
+  const constructor = getOwnErrorDescriptor(prototype, 'constructor');
+  if (
+    !name ||
+    !('value' in name) ||
+    name.value !== kind ||
+    !constructor ||
+    !('value' in constructor) ||
+    typeof constructor.value !== 'function'
+  ) {
+    return false;
+  }
+
+  const originalPrototype = getOwnErrorDescriptor(constructor.value, 'prototype');
+  const nativeSource = kind === 'Error' ? nativeErrorSource : nativeSyntaxErrorSource;
+  return Boolean(
+    originalPrototype &&
+    'value' in originalPrototype &&
+    originalPrototype.value === prototype &&
+    errorFunctionToString.call(constructor.value) === nativeSource,
+  );
+}
+
+function classifyCrossRealmAzureError(error: object): AzureJSONErrorKind {
+  try {
+    const prototypes: object[] = [];
+    let tagged = false;
+    for (
+      let prototype: object | null = error;
+      prototype !== null;
+      prototype = getErrorPrototype(prototype) as object | null
+    ) {
+      if (prototypes.length >= MAX_AZURE_IMDS_JSON_ERROR_CAUSES) {
+        return 'unsafe';
+      }
+      prototypes.push(prototype);
+      if (!nativeErrorBrand && getOwnErrorDescriptor(prototype, Symbol.toStringTag)) {
+        tagged = true;
+      }
+    }
+
+    if (
+      nativeErrorBrand
+        ? !nativeErrorBrand(error)
+        : !tagged && errorObjectToString.call(error) !== '[object Error]'
+    ) {
+      return 'unknown';
+    }
+
+    let genericErrorPrototype = false;
+    for (let index = 1; index < prototypes.length; index += 1) {
+      const prototype = prototypes[index];
+      if (!prototype) {
+        return 'unsafe';
+      }
+      if (hasNativeErrorPrototype(prototype, 'SyntaxError')) {
+        return tagged ? 'unsafe' : 'syntax';
+      }
+      if (tagged && hasNativeErrorPrototype(prototype, 'Error')) {
+        genericErrorPrototype = true;
+      }
+    }
+
+    if (!tagged) {
+      return 'error';
+    }
+    return genericErrorPrototype ? 'tagged-wrapper' : 'unknown';
+  } catch {
+    return 'unsafe';
+  }
+}
+
+function inspectAzureJSONErrorCause(error: unknown): boolean {
+  const visited = new Set<object>();
+  let current = error;
+
+  for (let depth = 0; depth < MAX_AZURE_IMDS_JSON_ERROR_CAUSES; depth += 1) {
+    if (current instanceof SyntaxError) {
+      return true;
+    }
+    if (typeof current !== 'object' || current === null) {
+      return false;
+    }
+    const kind = current instanceof Error ? 'error' : classifyCrossRealmAzureError(current);
+    if (kind === 'syntax' || kind === 'unsafe') {
+      return true;
+    }
+    if (kind !== 'error' && kind !== 'tagged-wrapper') {
+      return false;
+    }
+    if (kind === 'error') {
+      const parserType = getOwnErrorDescriptor(current, 'type');
+      if (parserType && 'value' in parserType && parserType.value === 'invalid-json') {
+        return true;
+      }
+    }
+    if (visited.has(current)) {
+      return true;
+    }
+    visited.add(current);
+
+    let cause: PropertyDescriptor | undefined;
+    try {
+      cause = getOwnErrorDescriptor(current, 'cause');
+    } catch {
+      return true;
+    }
+    if (!cause || !('value' in cause)) {
+      return false;
+    }
+    current = cause.value;
+  }
+
+  return true;
+}
+
+function isMalformedAzureJSONError(error: unknown): boolean {
+  try {
+    return inspectAzureJSONErrorCause(error);
+  } catch {
+    return true;
+  }
+}
 
 /** Reads the UTF-8 contents of a Kubernetes service-account token file. */
 type ReadFile = (path: string) => Promise<string>;
@@ -147,13 +288,43 @@ export function azureManagedIdentityTokenProvider(
         });
 
         if (!response.ok) {
+          let abortListener: (() => void) | undefined;
+
+          try {
+            // oxlint-disable-next-line promise/avoid-new -- AbortSignal is callback-only across supported runtimes.
+            const requestAborted = new Promise<void>((resolve) => {
+              abortListener = () => resolve();
+              if (controller.signal.aborted) {
+                abortListener();
+              } else {
+                controller.signal.addEventListener('abort', abortListener, { once: true });
+              }
+            });
+
+            await Promise.race([Shims.CancelReadableStream(response.body), requestAborted]);
+          } catch {
+            controller.abort();
+          } finally {
+            if (abortListener) {
+              controller.signal.removeEventListener('abort', abortListener);
+            }
+          }
+
           throw new SubjectTokenProviderError(
             `Failed to fetch token from Azure IMDS: status ${response.status}`,
             'azure-imds',
           );
         }
 
-        const data = (await response.json()) as { access_token?: string };
+        let data: { access_token?: string };
+        try {
+          data = (await response.json()) as { access_token?: string };
+        } catch (error) {
+          if (isMalformedAzureJSONError(error)) {
+            throw new SyntaxError('IMDS response contains invalid JSON');
+          }
+          throw error;
+        }
 
         if (!data.access_token) {
           throw new SubjectTokenProviderError("IMDS response missing 'access_token' field", 'azure-imds');
@@ -199,7 +370,7 @@ export function gcpIDTokenProvider(
     fetch?: Fetch;
   },
 ): SubjectTokenProvider {
-  const timeout = config?.timeout || 10_000;
+  const timeout = config?.timeout ?? 10_000;
 
   return {
     tokenType: 'id',
@@ -221,8 +392,29 @@ export function gcpIDTokenProvider(
         });
 
         if (!response.ok) {
-          const errorText = await response.text();
-          throw new Error(`GCP Metadata Server returned ${response.status}: ${errorText}`);
+          let abortListener: (() => void) | undefined;
+
+          try {
+            // oxlint-disable-next-line promise/avoid-new -- AbortSignal is callback-only across supported runtimes.
+            const requestAborted = new Promise<void>((resolve) => {
+              abortListener = () => resolve();
+              if (controller.signal.aborted) {
+                abortListener();
+              } else {
+                controller.signal.addEventListener('abort', abortListener, { once: true });
+              }
+            });
+
+            await Promise.race([Shims.CancelReadableStream(response.body), requestAborted]);
+          } catch {
+            controller.abort();
+          } finally {
+            if (abortListener) {
+              controller.signal.removeEventListener('abort', abortListener);
+            }
+          }
+
+          throw new Error(`GCP Metadata Server returned ${response.status}`);
         }
 
         const tokenText = await response.text();

package/src/auth/types.ts

@@ -25,6 +25,30 @@ export interface WorkloadIdentity {
   refreshBufferSeconds?: number;
 }
 
+/** Configures OpenAI-only federation from an explicitly attested X.509 client certificate. */
+export interface X509WorkloadIdentity {
+  /** Selects certificate-authenticated OAuth federation without an external subject token. */
+  type: 'x509';
+
+  /** Identity-provider resource enrolled for the caller-owned client certificate. */
+  identityProviderId: string;
+
+  /** OpenAI service account authorized for the verified certificate identity. */
+  serviceAccountId: string;
+
+  /** Optional milliseconds before expiry when the certificate-backed token should refresh. */
+  refreshBufferMs?: number;
+
+  /** X.509 federation proves certificate possession instead of supplying a subject token. */
+  provider?: never;
+
+  /** X.509 federation does not send an OAuth client identifier. */
+  clientId?: never;
+
+  /** X.509 federation does not accept subject-token refresh configuration. */
+  refreshBufferSeconds?: never;
+}
+
 /** OAuth token-exchange response returned by the OpenAI workload-identity endpoint. */
 export interface TokenExchangeResponse {
   /** OpenAI access token to use as the request's bearer credential. */

package/src/auth/workload-identity-auth.ts

@@ -14,6 +14,102 @@ const SUBJECT_TOKEN_TYPES: Record<WorkloadIdentity['provider']['tokenType'], str
 };
 
 const TOKEN_EXCHANGE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:token-exchange';
+const NATIVE_RESPONSE_PROTOTYPE = Response.prototype;
+const READ_NATIVE_RESPONSE_BODY = NATIVE_RESPONSE_PROTOTYPE.arrayBuffer;
+
+function isResponsePrototype(response: Response, prototype: object): boolean {
+  const constructor = Object.getOwnPropertyDescriptor(prototype, 'constructor')?.value;
+  if (
+    prototype === response ||
+    typeof constructor !== 'function' ||
+    Object.getOwnPropertyDescriptor(constructor, 'name')?.value !== 'Response' ||
+    Object.getOwnPropertyDescriptor(constructor, 'prototype')?.value !== prototype
+  ) {
+    return false;
+  }
+
+  const tag = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag);
+  return (
+    (tag?.value === 'Response' || typeof tag?.get === 'function') &&
+    typeof Object.getOwnPropertyDescriptor(prototype, 'headers')?.get === 'function' &&
+    typeof Object.getOwnPropertyDescriptor(prototype, 'ok')?.get === 'function' &&
+    typeof Object.getOwnPropertyDescriptor(prototype, 'status')?.get === 'function'
+  );
+}
+
+function isResponseBodyPrototype(prototype: object, responsePrototype: object | null): boolean {
+  if (prototype === responsePrototype) {
+    return true;
+  }
+
+  const constructor = Object.getOwnPropertyDescriptor(prototype, 'constructor')?.value;
+  return (
+    responsePrototype !== null &&
+    Object.getPrototypeOf(responsePrototype) === prototype &&
+    typeof constructor === 'function' &&
+    Object.getOwnPropertyDescriptor(constructor, 'name')?.value === 'Body' &&
+    Object.getOwnPropertyDescriptor(constructor, 'prototype')?.value === prototype
+  );
+}
+
+function decodeNativeResponseBody(body: ArrayBuffer): string {
+  const scope = globalThis as typeof globalThis & { Bun?: { version?: unknown } };
+  return new TextDecoder('utf-8', { ignoreBOM: typeof scope.Bun?.version === 'string' }).decode(body);
+}
+
+async function parseOAuthTokenResponse(response: Response): Promise<unknown> {
+  let readText: ((this: Response) => Promise<string>) | undefined;
+  let responsePrototype: object | null = null;
+  for (
+    let depth = 0, prototype: object | null = response;
+    prototype !== null && depth < 16;
+    prototype = Object.getPrototypeOf(prototype), depth += 1
+  ) {
+    if (prototype === NATIVE_RESPONSE_PROTOTYPE) {
+      break;
+    }
+
+    if (isResponsePrototype(response, prototype)) {
+      responsePrototype = prototype;
+    }
+
+    const parser = Object.getOwnPropertyDescriptor(prototype, 'json');
+    if (!parser) {
+      continue;
+    }
+
+    if (typeof parser.value !== 'function') {
+      break;
+    }
+
+    const bodyReader = Object.getOwnPropertyDescriptor(prototype, 'text')?.value;
+    if (typeof bodyReader === 'function' && isResponseBodyPrototype(prototype, responsePrototype)) {
+      readText = bodyReader;
+      break;
+    }
+
+    // Custom parsers own their results and failures; rejection provenance cannot be inferred.
+    return parser.value.call(response);
+  }
+
+  const body =
+    readText === undefined
+      ? decodeNativeResponseBody(await READ_NATIVE_RESPONSE_BODY.call(response))
+      : await readText.call(response);
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new SyntaxError('Token exchange response contains invalid JSON');
+  }
+}
+
+function isUnsafeAccessToken(accessToken: string): boolean {
+  const scope = globalThis as typeof globalThis & { Bun?: { version?: unknown } };
+  if (typeof scope.Bun?.version === 'string') {
+    return /[^\t\u0020-\u007E]|^[\t ]|[\t ]$/u.test(accessToken);
+  }
+  return /[^\t\u0020-\u007E\u0080-\u00FF]|^[\t ]|[\t ]$/u.test(accessToken);
+}
 
 /**
  * Exchanges external workload-identity tokens for cached OpenAI access tokens.
@@ -126,18 +222,19 @@ export class WorkloadIdentityAuth {
       );
     }
 
-    const tokenResponse: unknown = await response.json();
+    const tokenResponse: unknown = await parseOAuthTokenResponse(response);
+    const accessToken =
+      typeof tokenResponse === 'object' && tokenResponse !== null && 'access_token' in tokenResponse
+        ? tokenResponse.access_token
+        : undefined;
     if (
-      typeof tokenResponse !== 'object' ||
-      tokenResponse === null ||
-      !('access_token' in tokenResponse) ||
-      typeof tokenResponse.access_token !== 'string' ||
-      tokenResponse.access_token.trim().length === 0
+      typeof accessToken !== 'string' ||
+      accessToken.trim().length === 0 ||
+      isUnsafeAccessToken(accessToken)
     ) {
       throw new OpenAIError("Token exchange response missing 'access_token' field");
     }
 
-    const accessToken = tokenResponse.access_token;
     const expiresIn = (tokenResponse as Partial<TokenExchangeResponse>).expires_in ?? 3600;
     if (typeof expiresIn !== 'number' || !Number.isFinite(expiresIn) || expiresIn <= 0) {
       throw new OpenAIError("Token exchange response has invalid 'expires_in' field");

package/src/auth/x509-transport.ts

@@ -0,0 +1,49 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { setTimeout as delay } from 'node:timers/promises';
+import {
+  createX509Transport as createCapability,
+  registerX509Transport,
+  sendX509Request,
+} from '../internal/auth/x509-transport-capability';
+import type { X509Transport, X509TransportOptions } from '../internal/auth/x509-transport-capability';
+import { exchangeX509Token } from '../internal/auth/x509-token-exchange';
+import { isRetryableX509TransportFailure } from '../internal/auth/x509-transport-registry';
+import type { X509RequestScope } from '../internal/auth/x509-transport-registry';
+import { markTransientX509ConnectionError } from '#x509-transport-state';
+
+/** Creates one frozen, caller-attested Node.js transport for X.509 workload authentication. */
+export function createX509Transport(options: X509TransportOptions): X509Transport {
+  const capability = createCapability(options);
+  const scopes = new AsyncLocalStorage<X509RequestScope>();
+  registerX509Transport(capability, {
+    dispatch: async (target, requestOptions) => {
+      try {
+        return await sendX509Request(capability, target, requestOptions);
+      } catch (error) {
+        if (error instanceof Error && isRetryableX509TransportFailure(error)) {
+          markTransientX509ConnectionError(error);
+        }
+        throw error;
+      }
+    },
+    exchange: async (identityProviderId, serviceAccountId, signal) =>
+      await exchangeX509Token({
+        transport: capability,
+        identityProviderId,
+        serviceAccountId,
+        ...(signal ? { signal } : {}),
+      }),
+    run: (operation) =>
+      scopes.run({ wallStartedAt: Date.now(), monotonicStartedAt: performance.now() }, operation),
+    current: () => scopes.getStore(),
+    resume: (scope, operation) => scopes.run(scope, operation),
+    sleep: async (duration, signal) => await delay(duration, undefined, { signal: signal ?? undefined }),
+  });
+  return capability;
+}
+
+export type {
+  X509ProxyMode,
+  X509Transport,
+  X509TransportOptions,
+} from '../internal/auth/x509-transport-capability';

package/src/azure.ts

@@ -7,12 +7,26 @@ import { isObj, readEnv } from './internal/utils';
 import { path } from './internal/utils/path';
 import { OpenAI } from './client';
 import type { ClientOptions } from './client';
+import type { WorkloadIdentity } from './auth/types';
+import { assertNoDataResidency } from './internal/data-residency';
 
 /** API Client for interfacing with the Azure OpenAI API. */
-export interface AzureClientOptions extends Omit<ClientOptions, 'provider'> {
+export interface AzureClientOptions extends Omit<
+  ClientOptions,
+  'provider' | 'dataResidency' | 'workloadIdentity' | 'x509Transport'
+> {
   /** AzureOpenAI does not support third-party provider configuration. */
   provider?: never;
 
+  /** OpenAI data residency cannot be combined with Azure routing. */
+  dataResidency?: never;
+
+  /** Azure cannot receive OpenAI X.509 workload-identity certificate transports. */
+  x509Transport?: never;
+
+  /** Existing subject-token workload-identity configuration remains unchanged. */
+  workloadIdentity?: WorkloadIdentity | undefined;
+
   /**
    * Defaults to process.env['OPENAI_API_VERSION'].
    */
@@ -74,8 +88,10 @@ export class AzureOpenAI extends OpenAI {
     deployment,
     azureADTokenProvider,
     dangerouslyAllowBrowser,
+    dataResidency,
     ...opts
   }: AzureClientOptions = {}) {
+    assertNoDataResidency(dataResidency, 'AzureOpenAI');
     if (!apiVersion) {
       throw new Errors.OpenAIError(
         "The OPENAI_API_VERSION environment variable is missing or empty; either provide it, or instantiate the AzureOpenAI client with an apiVersion option, like new AzureOpenAI({ apiVersion: 'My API Version' }).",
@@ -131,6 +147,11 @@ export class AzureOpenAI extends OpenAI {
     this.deploymentName = deployment;
   }
 
+  /** Clones this client with Azure options; OpenAI data residency remains unsupported. */
+  override withOptions(options: Partial<AzureClientOptions>): this {
+    return super.withOptions(options);
+  }
+
   /** Builds an Azure request and inserts its deployment into model-scoped endpoint paths. */
   override async buildRequest(
     options: FinalRequestOptions,

package/src/bedrock.ts

@@ -1,7 +1,12 @@
 import * as Errors from './error';
 import { OpenAI } from './client';
 import type { ApiKeySetter, ClientOptions } from './client';
-import { assertBedrockRequestOrigin, brand_privateBedrockClient } from './internal/bedrock';
+import { assertNoDataResidency } from './internal/data-residency';
+import {
+  assertBedrockRequestOrigin,
+  assertValidBedrockBearerCredential,
+  brand_privateBedrockClient,
+} from './internal/bedrock';
 import type { RequestInit } from './internal/builtin-types';
 import type { NullableHeaders } from './internal/headers';
 import { buildHeaders } from './internal/headers';
@@ -15,7 +20,7 @@ import type * as ResponsesAPI from './resources/responses/responses';
 /** Configures Amazon Bedrock's OpenAI-compatible endpoint and bearer-token authentication. */
 export interface BedrockClientOptions extends Omit<
   ClientOptions,
-  'apiKey' | 'adminAPIKey' | 'baseURL' | 'workloadIdentity'
+  'apiKey' | 'adminAPIKey' | 'baseURL' | 'workloadIdentity' | 'x509Transport' | 'dataResidency'
 > {
   /**
    * Bedrock bearer token used for authentication.
@@ -38,11 +43,17 @@ export interface BedrockClientOptions extends Omit<
    */
   adminAPIKey?: never;
 
+  /** OpenAI data residency cannot be combined with Bedrock routing. */
+  dataResidency?: never;
+
   /**
    * BedrockOpenAI only supports Bedrock bearer token authentication.
    */
   workloadIdentity?: never;
 
+  /** Bedrock cannot receive OpenAI X.509 workload-identity certificate transports. */
+  x509Transport?: never;
+
   /**
    * AWS region used to derive the default Bedrock Mantle endpoint.
    *
@@ -64,6 +75,11 @@ function deriveBedrockBaseURL(awsRegion: string | undefined): string {
       'Must provide one of the `baseURL` or `awsRegion` arguments, or set the `AWS_BEDROCK_BASE_URL`, `AWS_REGION`, or `AWS_DEFAULT_REGION` environment variable.',
     );
   }
+  if (!/^[a-z]{2,8}(?:-[a-z0-9]+)+-\d+$/u.test(region)) {
+    throw new Errors.OpenAIError(
+      'The Bedrock AWS `region` is invalid. Use a standard AWS region such as `us-east-1`.',
+    );
+  }
 
   return `https://bedrock-mantle.${region}.api.aws/openai/v1`;
 }
@@ -129,9 +145,12 @@ export class BedrockOpenAI extends OpenAI {
     bedrockTokenProvider,
     adminAPIKey,
     workloadIdentity,
+    x509Transport,
+    dataResidency,
     ...opts
   }: BedrockClientOptions = {}) {
-    if (adminAPIKey || workloadIdentity) {
+    assertNoDataResidency(dataResidency, 'BedrockOpenAI');
+    if (adminAPIKey || workloadIdentity || x509Transport) {
       throw new Errors.OpenAIError('BedrockOpenAI only supports Bedrock bearer token authentication.');
     }
 
@@ -166,6 +185,21 @@ export class BedrockOpenAI extends OpenAI {
       ...opts,
     });
 
+    let currentApiKey = this.apiKey;
+    Object.defineProperty(this, 'apiKey', {
+      enumerable: true,
+      configurable: true,
+      get() {
+        if (currentApiKey !== null) {
+          assertValidBedrockBearerCredential(currentApiKey);
+        }
+        return currentApiKey;
+      },
+      set(nextApiKey: string | null) {
+        currentApiKey = nextApiKey;
+      },
+    });
+
     const trustedBaseURL = this.baseURL;
     let currentBaseURL = trustedBaseURL;
     Object.defineProperty(this, 'baseURL', {
@@ -211,8 +245,18 @@ export class BedrockOpenAI extends OpenAI {
     schemes?: { bearerAuth?: boolean; adminAPIKeyAuth?: boolean },
   ): Promise<NullableHeaders | undefined> {
     const security = schemes ?? { bearerAuth: true, adminAPIKeyAuth: true };
-    if ((security.bearerAuth || security.adminAPIKeyAuth) && this.apiKey !== null) {
-      return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+    const credential = this.apiKey;
+    if ((security.bearerAuth || security.adminAPIKeyAuth) && credential !== null) {
+      assertValidBedrockBearerCredential(credential);
+      try {
+        return buildHeaders([{ Authorization: `Bearer ${credential}` }]);
+      } catch (error) {
+        if (error instanceof TypeError) {
+          // oxlint-disable-next-line eslint/preserve-caught-error -- The original error contains the bearer credential.
+          throw new TypeError('Bedrock bearer credential contains an invalid HTTP header value.');
+        }
+        throw error;
+      }
     }
 
     return super.authHeaders(opts, security);

package/src/beta/realtime/internal-base.ts

@@ -7,6 +7,20 @@ import { EventEmitter } from '../../lib/EventEmitter';
 import { OpenAIError } from '../../error';
 import type OpenAI from '../../index';
 import { AzureOpenAI } from '../../index';
+import { assertX509WebSocketSupported } from '../../internal/auth/x509-workload-identity-auth';
+
+/** Parses frame data without exposing malformed payloads through JSON syntax errors. */
+export function parseRealtimeEvent(data: string): RealtimeServerEvent {
+  try {
+    return JSON.parse(data) as RealtimeServerEvent;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new SyntaxError('Could not parse Realtime WebSocket event data as JSON.');
+    }
+
+    throw error;
+  }
+}
 
 function safeErrorValue(value: unknown): string {
   try {
@@ -164,6 +178,7 @@ export function buildRealtimeURL(
   client: Pick<OpenAI, 'apiKey' | 'baseURL'>,
   connection: string | RealtimeConnectionConfig,
 ): URL {
+  assertX509WebSocketSupported(client);
   const config: RealtimeConnectionConfig =
     typeof connection === 'string' ? { model: connection } : connection;
   const baseURL = client.baseURL;