openai 7.5.0 → 7.6.0

package/src/beta/realtime/websocket.ts

@@ -2,8 +2,8 @@ import type { AzureOpenAI } from '../../index';
 import { assertBedrockWebSocketOrigin } from '../../internal/bedrock';
 import { OpenAI } from '../../index';
 import { OpenAIError } from '../../error';
-import type { RealtimeClientEvent, RealtimeServerEvent } from '../../resources/beta/realtime/realtime';
-import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+import type { RealtimeClientEvent } from '../../resources/beta/realtime/realtime';
+import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure, parseRealtimeEvent } from './internal-base';
 import type { RealtimeConnectionConfig } from './internal-base';
 import { isRunningInBrowser } from '../../internal/detect-platform';
 
@@ -20,10 +20,82 @@ type _WebSocket = typeof globalThis extends {
     InstanceType<ws>
   : any;
 
-/** Removes Azure credential query values from the publicly exposed connection URL. */
-function redactAzureCredentials(url: URL): void {
-  const hasAuthorization = url.searchParams.has('Authorization');
-  if (url.searchParams.has('api-key') || !hasAuthorization) {
+type RuntimeScope = typeof globalThis & {
+  process?: { versions?: { node?: string } };
+  WorkerGlobalScope?: typeof Object;
+  WorkerNavigator?: typeof Object;
+  Deno?: { version?: { deno?: string } };
+  Bun?: { version?: string };
+  EdgeRuntime?: unknown;
+  WebSocketPair?: unknown;
+};
+
+/** Identifies browser pages and workers without blocking trusted server runtimes. */
+function isRunningInBrowserOrBrowserWorker(): boolean {
+  if (isRunningInBrowser()) {
+    return true;
+  }
+
+  const scope = globalThis as RuntimeScope;
+  return (
+    typeof scope.WorkerGlobalScope === 'function' &&
+    scope instanceof scope.WorkerGlobalScope &&
+    typeof scope.WorkerNavigator === 'function' &&
+    scope.navigator instanceof scope.WorkerNavigator &&
+    typeof scope.navigator?.userAgent === 'string' &&
+    scope.navigator.userAgent !== 'Cloudflare-Workers' &&
+    scope.process?.versions?.node === undefined &&
+    scope.Deno === undefined &&
+    scope.Bun === undefined &&
+    scope.EdgeRuntime === undefined &&
+    scope.WebSocketPair === undefined
+  );
+}
+
+/** Reports whether the runtime supports request headers in native WebSocket options. */
+function supportsWebSocketRequestHeaders(): boolean {
+  const scope = globalThis as RuntimeScope;
+  if (
+    isRunningInBrowserOrBrowserWorker() ||
+    scope.EdgeRuntime !== undefined ||
+    scope.WebSocketPair !== undefined ||
+    scope.navigator?.userAgent === 'Cloudflare-Workers'
+  ) {
+    return false;
+  }
+
+  if (scope.Deno !== undefined) {
+    const [major, minor] = (scope.Deno.version?.deno ?? '').split('.').map(Number);
+    return major !== undefined && minor !== undefined && (major > 2 || (major === 2 && minor >= 5));
+  }
+
+  if (typeof scope.Bun?.version === 'string') {
+    return true;
+  }
+
+  return (
+    Object.prototype.toString.call(scope.process) === '[object process]' &&
+    typeof scope.process?.versions?.node === 'string'
+  );
+}
+
+/** Removes Azure credentials while preserving the existing public URL redaction contract. */
+function redactAzureCredentials(url: URL, isBearerToken: boolean): void {
+  let hasApiKey = !isBearerToken;
+  let hasAuthorization = isBearerToken;
+  const parameterNames = [...url.searchParams.keys()];
+
+  for (const name of parameterNames) {
+    if (name.toLowerCase() === 'api-key') {
+      hasApiKey = true;
+      url.searchParams.delete(name);
+    } else if (name.toLowerCase() === 'authorization') {
+      hasAuthorization = true;
+      url.searchParams.delete(name);
+    }
+  }
+
+  if (hasApiKey) {
     url.searchParams.set('api-key', '<REDACTED>');
   }
   if (hasAuthorization) {
@@ -31,6 +103,45 @@ function redactAzureCredentials(url: URL): void {
   }
 }
 
+/** Opens an Azure native socket with header authentication and a credential-free URL. */
+function createAzureWebSocket(
+  url: URL,
+  apiKey: string | null,
+  isBearerToken: boolean,
+  protocols: string[],
+): _WebSocket {
+  if (!supportsWebSocketRequestHeaders()) {
+    throw new OpenAIError(
+      'Azure OpenAI Realtime credentials require a WebSocket transport that supports request headers; use openai/realtime/ws or a server-side authentication proxy.',
+    );
+  }
+  if (!apiKey) {
+    throw new Error('Azure OpenAI Realtime requires an API key');
+  }
+
+  redactAzureCredentials(url, isBearerToken);
+  const socketURL = new URL(url);
+  socketURL.searchParams.delete('api-key');
+  socketURL.searchParams.delete('Authorization');
+  const headers = isBearerToken ? { Authorization: `Bearer ${apiKey}` } : { 'api-key': apiKey };
+
+  // @ts-ignore
+  return new WebSocket(socketURL.toString(), { protocols, headers });
+}
+
+/** Prevents credentials from being attached outside the configured secure origin. */
+function assertTrustedRealtimeURL(client: Pick<OpenAI, 'apiKey' | 'baseURL'>, url: URL): void {
+  if (url.protocol !== 'wss:') {
+    throw new OpenAIError('Realtime WebSocket URLs must use the wss: protocol.');
+  }
+
+  const configuredURL = new URL(client.baseURL);
+  configuredURL.protocol = 'wss:';
+  if (url.origin !== configuredURL.origin) {
+    throw new OpenAIError('Realtime WebSocket URL origin must match the configured client origin.');
+  }
+}
+
 /**
  * Connects to the beta Realtime API using the runtime's native `WebSocket` implementation.
  *
@@ -39,13 +150,6 @@ function redactAzureCredentials(url: URL): void {
  * listener before using the connection. Use the stable Realtime helper for
  * Azure sideband calls.
  */
-function resolveRealtimeURL(
-  client: Pick<OpenAI, 'apiKey' | 'baseURL'>,
-  props: RealtimeConnectionConfig & { __url?: URL | undefined },
-): URL {
-  return props.__url ?? buildRealtimeURL(client, props);
-}
-
 export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
   /** Secure beta Realtime WebSocket URL; Azure authentication query parameters are redacted. */
   url: URL;
@@ -77,9 +181,6 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
       onURL?: (url: URL) => void;
       /** Indicates the token was resolved by the factory just before connecting. @internal */
       __resolvedApiKey?: boolean;
-
-      /** Final URL validated before an asynchronous credential provider ran. @internal */
-      __url?: URL;
     },
     client?: Pick<OpenAI, 'apiKey' | 'baseURL'>,
   ) {
@@ -89,7 +190,7 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
       props.dangerouslyAllowBrowser ??
       (client as any)?._options?.dangerouslyAllowBrowser ??
       (client?.apiKey?.startsWith('ek_') ? true : null);
-    if (!dangerouslyAllowBrowser && isRunningInBrowser()) {
+    if (!dangerouslyAllowBrowser && isRunningInBrowserOrBrowserWorker()) {
       throw new OpenAIError(
         "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\n\nYou can avoid this error by creating an ephemeral session token:\nhttps://platform.openai.com/docs/api-reference/realtime-sessions\n",
       );
@@ -106,21 +207,38 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
       );
     }
 
-    this.url = resolveRealtimeURL(client, props);
+    this.url = buildRealtimeURL(client, props);
     props.onURL?.(this.url);
+    assertTrustedRealtimeURL(client, this.url);
     assertBedrockWebSocketOrigin(client, this.url);
 
-    // @ts-ignore
-    this.socket = new WebSocket(this.url.toString(), [
+    const azure = isAzure(client);
+    const protocols = [
       'realtime',
-      ...(isAzure(client) ? [] : [`openai-insecure-api-key.${client.apiKey}`]),
+      ...(azure ? [] : [`openai-insecure-api-key.${client.apiKey}`]),
       'openai-beta.realtime-v1',
-    ]);
+    ];
+
+    this.socket = azure
+      ? createAzureWebSocket(this.url, client.apiKey, props.__resolvedApiKey === true, protocols)
+      : new WebSocket(this.url.toString(), protocols);
 
     this.socket.addEventListener('message', (websocketEvent: MessageEvent) => {
       const event = (() => {
         try {
-          return JSON.parse(websocketEvent.data.toString()) as RealtimeServerEvent;
+          const parsedEvent = parseRealtimeEvent(websocketEvent.data.toString());
+
+          if (
+            typeof parsedEvent !== 'object' ||
+            parsedEvent === null ||
+            Array.isArray(parsedEvent) ||
+            !Object.getOwnPropertyDescriptor(parsedEvent, 'type') ||
+            typeof parsedEvent.type !== 'string'
+          ) {
+            throw new TypeError('Realtime WebSocket event must be an object with a string type.');
+          }
+
+          return parsedEvent;
         } catch (err) {
           this._onError(null, 'could not parse websocket event', err);
           return null;
@@ -142,10 +260,6 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
     this.socket.addEventListener('error', (event: any) => {
       this._onError(null, event.message, null);
     });
-
-    if (isAzure(client)) {
-      redactAzureCredentials(this.url);
-    }
   }
 
   /**
@@ -164,17 +278,20 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
     },
   ): Promise<OpenAIRealtimeWebSocket> {
     const url = buildRealtimeURL(client, props);
+    assertTrustedRealtimeURL(client, url);
     assertBedrockWebSocketOrigin(client, url);
     const resolvedApiKey = await client._callApiKey();
-    return new OpenAIRealtimeWebSocket({ ...props, __resolvedApiKey: resolvedApiKey, __url: url }, client);
+    assertTrustedRealtimeURL(client, url);
+    assertBedrockWebSocketOrigin(client, url);
+    return new OpenAIRealtimeWebSocket({ ...props, __resolvedApiKey: resolvedApiKey }, client);
   }
 
   /**
    * Opens a native beta Azure OpenAI Realtime session for a model deployment.
    *
-   * Azure credentials are redacted from the exposed `url` property immediately
-   * after connection setup. Use the stable Realtime helper to attach to an
-   * existing Azure call.
+   * Azure credentials are sent in WebSocket handshake headers and never appear
+   * in the native socket URL. Browser WebSockets cannot set these headers;
+   * use a server-side authentication proxy or the Node.js `ws` transport.
    *
    * @param client Azure OpenAI client that supplies the endpoint and credential.
    * @param options Optional deployment override and browser-safety settings.
@@ -195,14 +312,6 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
     if (!apiKey) {
       throw new Error('Azure OpenAI Realtime requires an API key');
     }
-    const azureApiKey = apiKey;
-    function onURL(url: URL) {
-      if (isApiKeyProvider) {
-        url.searchParams.set('Authorization', `Bearer ${azureApiKey}`);
-      } else {
-        url.searchParams.set('api-key', azureApiKey);
-      }
-    }
     const deploymentName = options.deploymentName ?? client.deploymentName;
     if (!deploymentName) {
       throw new Error('No deployment name provided');
@@ -211,7 +320,6 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
     return new OpenAIRealtimeWebSocket(
       {
         model: deploymentName,
-        onURL,
         ...(dangerouslyAllowBrowser === undefined ? {} : { dangerouslyAllowBrowser }),
         __resolvedApiKey: isApiKeyProvider,
       },

package/src/beta/realtime/ws.ts

@@ -3,8 +3,8 @@ import { assertBedrockWebSocketOrigin } from '../../internal/bedrock';
 import { protectWebSocketOptionsFromCredentialRedirects } from '../../internal/ws';
 import type { AzureOpenAI } from '../../index';
 import { OpenAI } from '../../index';
-import type { RealtimeClientEvent, RealtimeServerEvent } from '../../resources/beta/realtime/realtime';
-import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+import type { RealtimeClientEvent } from '../../resources/beta/realtime/realtime';
+import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure, parseRealtimeEvent } from './internal-base';
 import type { RealtimeConnectionConfig } from './internal-base';
 
 /**
@@ -14,11 +14,16 @@ import type { RealtimeConnectionConfig } from './internal-base';
  * Register an SDK `error` listener and wait for `socket`'s `open` event before
  * sending client events. Use the stable Realtime helper for Azure sideband calls.
  */
-function resolveRealtimeURL(
-  client: Pick<OpenAI, 'apiKey' | 'baseURL'>,
-  props: RealtimeConnectionConfig & { __url?: URL | undefined },
-): URL {
-  return props.__url ?? buildRealtimeURL(client, props);
+function assertTrustedRealtimeURL(client: Pick<OpenAI, 'apiKey' | 'baseURL'>, url: URL): void {
+  if (url.protocol !== 'wss:') {
+    throw new Error('Realtime WebSocket URLs must use the wss: protocol.');
+  }
+
+  const configuredURL = new URL(client.baseURL);
+  configuredURL.protocol = 'wss:';
+  if (url.origin !== configuredURL.origin) {
+    throw new Error('Realtime WebSocket URL origin must match the configured client origin.');
+  }
 }
 
 export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
@@ -45,9 +50,6 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
 
       /** Indicates that a function-based credential was resolved by an async factory. @internal */
       __resolvedApiKey?: boolean;
-
-      /** Final URL validated before an asynchronous credential provider ran. @internal */
-      __url?: URL;
     },
     client?: Pick<OpenAI, 'apiKey' | 'baseURL'>,
   ) {
@@ -62,7 +64,8 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
         ].join('\n'),
       );
     }
-    this.url = resolveRealtimeURL(client, props);
+    this.url = buildRealtimeURL(client, props);
+    assertTrustedRealtimeURL(client, this.url);
     assertBedrockWebSocketOrigin(client, this.url);
     const headers = {
       ...props.options?.headers,
@@ -81,7 +84,19 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
     this.socket.on('message', (wsEvent) => {
       const event = (() => {
         try {
-          return JSON.parse(wsEvent.toString()) as RealtimeServerEvent;
+          const parsedEvent = parseRealtimeEvent(wsEvent.toString());
+
+          if (
+            typeof parsedEvent !== 'object' ||
+            parsedEvent === null ||
+            Array.isArray(parsedEvent) ||
+            !Object.getOwnPropertyDescriptor(parsedEvent, 'type') ||
+            typeof parsedEvent.type !== 'string'
+          ) {
+            throw new TypeError('Realtime WebSocket event must be an object with a string type.');
+          }
+
+          return parsedEvent;
         } catch (err) {
           this._onError(null, 'could not parse websocket event', err);
           return null;
@@ -121,9 +136,12 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
     },
   ): Promise<OpenAIRealtimeWS> {
     const url = buildRealtimeURL(client, props);
+    assertTrustedRealtimeURL(client, url);
     assertBedrockWebSocketOrigin(client, url);
     const resolvedApiKey = await client._callApiKey();
-    return new OpenAIRealtimeWS({ ...props, __resolvedApiKey: resolvedApiKey, __url: url }, client);
+    assertTrustedRealtimeURL(client, url);
+    assertBedrockWebSocketOrigin(client, url);
+    return new OpenAIRealtimeWS({ ...props, __resolvedApiKey: resolvedApiKey }, client);
   }
 
   /**