@ai-sdk/openai 4.0.11 → 4.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.11",
+  "version": "4.0.14",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.3",
-    "@ai-sdk/provider-utils": "5.0.7"
+    "@ai-sdk/provider-utils": "5.0.10"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/openai-provider.ts

@@ -13,6 +13,7 @@ import type {
 import {
   loadApiKey,
   loadOptionalSetting,
+  validateBaseURL,
   withoutTrailingSlash,
   withUserAgentSuffix,
   type FetchFunction,
@@ -175,10 +176,12 @@ export function createOpenAI(
 ): OpenAIProvider {
   const baseURL =
     withoutTrailingSlash(
-      loadOptionalSetting({
-        settingValue: options.baseURL,
-        environmentVariableName: 'OPENAI_BASE_URL',
-      }),
+      validateBaseURL(
+        loadOptionalSetting({
+          settingValue: options.baseURL,
+          environmentVariableName: 'OPENAI_BASE_URL',
+        }),
+      ),
     ) ?? 'https://api.openai.com/v1';
 
   const providerName = options.name ?? 'openai';

package/src/transcription/openai-transcription-model.ts

@@ -10,16 +10,18 @@ import {
   convertBase64ToUint8Array,
   convertToBase64,
   createJsonResponseHandler,
-  getWebSocketConstructor,
+  connectToWebSocket,
   mediaTypeToExtension,
   parseProviderOptions,
   postFormDataToApi,
-  readWebSocketMessageText,
   safeParseJSON,
   serializeModelOptions,
   toWebSocketUrl,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
+  waitForWebSocketBufferDrain,
+  type WebSocketConnection,
+  type WebSocketLike,
 } from '@ai-sdk/provider-utils';
 import type { OpenAIConfig } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
@@ -390,22 +392,21 @@ function createOpenAIRealtimeTranscriptionStream({
 
   return new ReadableStream({
     start: controller => {
-      const WebSocketConstructor = getWebSocketConstructor(webSocket);
-      const ws = new WebSocketConstructor(
-        url,
-        getOpenAIRealtimeProtocols(headers),
-        { headers },
-      );
+      const realtimeConnection = getOpenAIRealtimeConnection(headers);
       let audioReader:
         | ReadableStreamDefaultReader<Uint8Array | string>
         | undefined;
+      let connection: WebSocketConnection | undefined;
 
       cleanup = (closeCode?: number) => {
-        abortSignal?.removeEventListener('abort', abort);
-        void audioReader?.cancel().catch(() => {});
-        try {
-          ws.close(closeCode);
-        } catch {}
+        if (audioReader != null) {
+          void audioReader.cancel().catch(() => {});
+        } else {
+          // pre-open failure or abort: cancel the caller's audio stream so an
+          // upstream producer piping into it does not hang:
+          void audio.cancel().catch(() => {});
+        }
+        connection?.close(closeCode);
       };
 
       const finishWithError = (error: unknown) => {
@@ -431,89 +432,86 @@ function createOpenAIRealtimeTranscriptionStream({
         cleanup(1000);
       };
 
-      const abort = () => {
-        finishWithError(abortSignal?.reason ?? new Error('Aborted'));
-      };
-      if (abortSignal?.aborted) {
-        abort();
-        return;
-      }
-      abortSignal?.addEventListener('abort', abort, { once: true });
-
-      const sendAudio = async () => {
+      const sendAudio = async (socket: WebSocketLike) => {
         audioReader = audio.getReader();
         try {
           while (true) {
             const { done, value } = await audioReader.read();
             if (done || finished) break;
-            ws.send(
+            socket.send(
               JSON.stringify({
                 type: 'input_audio_buffer.append',
                 audio: convertToBase64(value),
               }),
             );
+            // backpressure: pause reads while the socket buffer is full
+            await waitForWebSocketBufferDrain(socket);
           }
         } finally {
           audioReader.releaseLock();
+          // unlocked again: cleanup must cancel `audio`, not the reader
+          audioReader = undefined;
         }
         if (!finished) {
-          ws.send(JSON.stringify({ type: 'input_audio_buffer.commit' }));
+          socket.send(JSON.stringify({ type: 'input_audio_buffer.commit' }));
         }
       };
 
-      ws.onopen = () => {
-        controller.enqueue({ type: 'stream-start', warnings });
-        ws.send(JSON.stringify(sessionUpdate));
-        void sendAudio().catch(finishWithError);
-      };
+      connection = connectToWebSocket({
+        url,
+        protocols: realtimeConnection.protocols,
+        headers: realtimeConnection.headers,
+        webSocket,
+        abortSignal,
+        onAbort: finishWithError,
+        onProcessingError: finishWithError,
+        onOpen: socket => {
+          controller.enqueue({ type: 'stream-start', warnings });
+          socket.send(JSON.stringify(sessionUpdate));
+          void sendAudio(socket).catch(finishWithError);
+        },
+        onMessageText: async text => {
+          const parsed = await safeParseJSON({ text });
+          if (!parsed.success) return;
+          const raw = parsed.value as OpenAIRealtimeTranscriptionEvent;
 
-      ws.onmessage = event => {
-        void readWebSocketMessageText(event.data)
-          .then(async text => {
-            const parsed = await safeParseJSON({ text });
-            if (!parsed.success) return;
-            const raw = parsed.value as OpenAIRealtimeTranscriptionEvent;
+          if (includeRawChunks) {
+            controller.enqueue({ type: 'raw', rawValue: raw });
+          }
 
-            if (includeRawChunks) {
-              controller.enqueue({ type: 'raw', rawValue: raw });
+          switch (raw.type) {
+            case 'conversation.item.input_audio_transcription.delta': {
+              controller.enqueue({
+                type: 'transcript-delta',
+                id: raw.item_id,
+                delta: raw.delta ?? '',
+              });
+              break;
             }
 
-            switch (raw.type) {
-              case 'conversation.item.input_audio_transcription.delta': {
-                controller.enqueue({
-                  type: 'transcript-delta',
-                  id: raw.item_id,
-                  delta: raw.delta ?? '',
-                });
-                break;
-              }
-
-              case 'conversation.item.input_audio_transcription.completed': {
-                finish(raw.transcript ?? '', raw.item_id);
-                break;
-              }
-
-              case 'error': {
-                finishWithError(
-                  new Error(raw.error?.message ?? 'OpenAI realtime error'),
-                );
-                break;
-              }
+            case 'conversation.item.input_audio_transcription.completed': {
+              finish(raw.transcript ?? '', raw.item_id);
+              break;
             }
-          })
-          .catch(finishWithError);
-      };
-
-      ws.onerror = () => {
-        finishWithError(new Error('OpenAI realtime transcription error'));
-      };
 
-      ws.onclose = () => {
-        if (finished) return;
-        finished = true;
-        cleanup();
-        controller.close();
-      };
+            case 'error': {
+              finishWithError(
+                new Error(raw.error?.message ?? 'OpenAI realtime error'),
+              );
+              break;
+            }
+          }
+        },
+        onSocketError: () => {
+          finishWithError(new Error('OpenAI realtime transcription error'));
+        },
+        onClose: () => {
+          if (finished) return;
+          finished = true;
+          cleanup();
+          controller.close();
+        },
+      });
     },
 
     cancel: () => {
@@ -564,15 +562,36 @@ function buildOpenAIRealtimeTranscriptionSession({
   };
 }
 
-function getOpenAIRealtimeProtocols(
+// The bearer token rides the `openai-insecure-api-key` subprotocol (native
+// `WebSocket` cannot send headers) and the Authorization header is stripped:
+// OpenAI rejects handshakes that send both auth channels.
+function getOpenAIRealtimeConnection(
   headers: Record<string, string | undefined>,
-): string[] {
-  const authorization = headers.Authorization ?? headers.authorization;
-  const token = authorization?.startsWith('Bearer ')
-    ? authorization.slice('Bearer '.length)
-    : undefined;
-
-  return token == null
-    ? ['realtime']
-    : ['realtime', `openai-insecure-api-key.${token}`];
+): {
+  protocols: string[];
+  headers: Record<string, string | undefined>;
+} {
+  // last case-variant wins: combineHeaders keeps case-distinct keys and
+  // spreads per-call headers after configuration headers
+  let authorization: string | undefined;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === 'authorization' && value != null) {
+      authorization = value;
+    }
+  }
+  // the HTTP auth scheme is case-insensitive
+  const token = authorization?.match(/^bearer\s+(.+)$/i)?.[1];
+
+  if (token == null) {
+    return { protocols: ['realtime'], headers };
+  }
+
+  return {
+    protocols: ['realtime', `openai-insecure-api-key.${token}`],
+    headers: Object.fromEntries(
+      Object.entries(headers).filter(
+        ([key]) => key.toLowerCase() !== 'authorization',
+      ),
+    ),
+  };
 }