@ai-sdk/openai 4.0.11 → 4.0.14

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @ai-sdk/openai
 
+## 4.0.14
+
+### Patch Changes
+
+- Updated dependencies [31c7be8]
+  - @ai-sdk/provider-utils@5.0.10
+
+## 4.0.13
+
+### Patch Changes
+
+- 7805e4a: Fix realtime transcription auth header handling: per-call `authorization` headers now override configuration headers regardless of header-key casing (last case-variant wins), and the `Bearer` scheme is matched case-insensitively.
+- cd12954: Reject empty OpenAI, Anthropic, and Replicate base URLs with a helpful AI SDK
+  invalid argument error.
+- Updated dependencies [4be62c1]
+- Updated dependencies [7805e4a]
+- Updated dependencies [cd12954]
+  - @ai-sdk/provider-utils@5.0.9
+
+## 4.0.12
+
+### Patch Changes
+
+- e193290: Add `connectToWebSocket` to `@ai-sdk/provider-utils`: a shared WebSocket connect layer (constructor resolution, header hygiene, abort wiring, message decoding) analogous to `postToApi` for HTTP. The openai and xai streaming transcription models now use it instead of hand-rolled connects. For openai and xai this also means WebSocket constructor failures now surface as stream errors instead of throwing synchronously from `doStream`, an already-aborted signal no longer constructs a socket, and the caller's audio stream is cancelled on pre-open failures. Messages are processed in order with close handling deferred behind pending frames, audio send loops apply backpressure via the socket's bufferedAmount, and failed sends cancel the caller's audio stream.
+- e193290: Fix streaming transcription over header-capable WebSocket implementations: the realtime WebSocket handshake sent the api key in both the `openai-insecure-api-key` subprotocol and the `Authorization` header, which OpenAI rejects ("You must only send one of protocol api key and Authorization header"). The Authorization header is now stripped when the subprotocol carries the key.
+- e193290: Strip undefined header values before the streaming transcription WebSocket constructor (header-capable implementations like `ws` throw on undefined values).
+- Updated dependencies [e193290]
+  - @ai-sdk/provider-utils@5.0.8
+
 ## 4.0.11
 
 ### Patch Changes

package/dist/index.js

@@ -2,6 +2,7 @@
 import {
   loadApiKey,
   loadOptionalSetting,
+  validateBaseURL,
   withoutTrailingSlash,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
@@ -7907,16 +7908,16 @@ import {
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
   convertToBase64 as convertToBase643,
   createJsonResponseHandler as createJsonResponseHandler7,
-  getWebSocketConstructor,
+  connectToWebSocket,
   mediaTypeToExtension,
   parseProviderOptions as parseProviderOptions9,
   postFormDataToApi as postFormDataToApi3,
-  readWebSocketMessageText,
   safeParseJSON,
   serializeModelOptions as serializeModelOptions7,
   toWebSocketUrl,
   WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE7,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE7
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE7,
+  waitForWebSocketBufferDrain
 } from "@ai-sdk/provider-utils";
 
 // src/transcription/openai-transcription-api.ts
@@ -8265,21 +8266,18 @@ 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;
+      let connection;
       cleanup = (closeCode) => {
-        abortSignal == null ? void 0 : abortSignal.removeEventListener("abort", abort);
-        void (audioReader == null ? void 0 : audioReader.cancel().catch(() => {
-        }));
-        try {
-          ws.close(closeCode);
-        } catch (e) {
+        if (audioReader != null) {
+          void audioReader.cancel().catch(() => {
+          });
+        } else {
+          void audio.cancel().catch(() => {
+          });
         }
+        connection == null ? void 0 : connection.close(closeCode);
       };
       const finishWithError = (error) => {
         if (finished) return;
@@ -8302,42 +8300,42 @@ function createOpenAIRealtimeTranscriptionStream({
         controller.close();
         cleanup(1e3);
       };
-      const abort = () => {
-        var _a;
-        finishWithError((_a = abortSignal == null ? void 0 : abortSignal.reason) != null ? _a : new Error("Aborted"));
-      };
-      if (abortSignal == null ? void 0 : abortSignal.aborted) {
-        abort();
-        return;
-      }
-      abortSignal == null ? void 0 : abortSignal.addEventListener("abort", abort, { once: true });
-      const sendAudio = async () => {
+      const sendAudio = async (socket) => {
         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: convertToBase643(value)
               })
             );
+            await waitForWebSocketBufferDrain(socket);
           }
         } finally {
           audioReader.releaseLock();
+          audioReader = void 0;
         }
         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);
-      };
-      ws.onmessage = (event) => {
-        void readWebSocketMessageText(event.data).then(async (text) => {
+      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) => {
           var _a, _b, _c, _d;
           const parsed = await safeParseJSON({ text });
           if (!parsed.success) return;
@@ -8365,17 +8363,17 @@ function createOpenAIRealtimeTranscriptionStream({
               break;
             }
           }
-        }).catch(finishWithError);
-      };
-      ws.onerror = () => {
-        finishWithError(new Error("OpenAI realtime transcription error"));
-      };
-      ws.onclose = () => {
-        if (finished) return;
-        finished = true;
-        cleanup();
-        controller.close();
-      };
+        },
+        onSocketError: () => {
+          finishWithError(new Error("OpenAI realtime transcription error"));
+        },
+        onClose: () => {
+          if (finished) return;
+          finished = true;
+          cleanup();
+          controller.close();
+        }
+      });
     },
     cancel: () => {
       if (finished) return;
@@ -8412,11 +8410,26 @@ function buildOpenAIRealtimeTranscriptionSession({
     }
   };
 }
-function getOpenAIRealtimeProtocols(headers) {
+function getOpenAIRealtimeConnection(headers) {
   var _a;
-  const authorization = (_a = headers.Authorization) != null ? _a : headers.authorization;
-  const token = (authorization == null ? void 0 : authorization.startsWith("Bearer ")) ? authorization.slice("Bearer ".length) : void 0;
-  return token == null ? ["realtime"] : ["realtime", `openai-insecure-api-key.${token}`];
+  let authorization;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "authorization" && value != null) {
+      authorization = value;
+    }
+  }
+  const token = (_a = authorization == null ? void 0 : authorization.match(/^bearer\s+(.+)$/i)) == null ? void 0 : _a[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"
+      )
+    )
+  };
 }
 
 // src/skills/openai-skills.ts
@@ -8504,16 +8517,18 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.11" : "0.0.0-test";
+var VERSION = true ? "4.0.14" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {
   var _a, _b;
   const baseURL = (_a = withoutTrailingSlash(
-    loadOptionalSetting({
-      settingValue: options.baseURL,
-      environmentVariableName: "OPENAI_BASE_URL"
-    })
+    validateBaseURL(
+      loadOptionalSetting({
+        settingValue: options.baseURL,
+        environmentVariableName: "OPENAI_BASE_URL"
+      })
+    )
   )) != null ? _a : "https://api.openai.com/v1";
   const providerName = (_b = options.name) != null ? _b : "openai";
   const getHeaders = () => withUserAgentSuffix(