@ai-sdk/provider-utils 5.0.6 → 5.0.9

package/dist/index.js

@@ -14,6 +14,155 @@ function combineHeaders(...headers) {
   );
 }
 
+// src/remove-undefined-entries.ts
+function removeUndefinedEntries(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([_key, value]) => value != null)
+  );
+}
+
+// src/delay.ts
+async function delay(delayInMs, options) {
+  if (delayInMs == null) {
+    return Promise.resolve();
+  }
+  const signal = options == null ? void 0 : options.abortSignal;
+  return new Promise((resolve2, reject) => {
+    if (signal == null ? void 0 : signal.aborted) {
+      reject(createAbortError());
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve2();
+    }, delayInMs);
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(createAbortError());
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
+  });
+}
+function createAbortError() {
+  return new DOMException("Delay was aborted", "AbortError");
+}
+
+// src/websocket.ts
+function getWebSocketConstructor(webSocket) {
+  const WebSocketConstructor = webSocket != null ? webSocket : globalThis.WebSocket;
+  if (WebSocketConstructor == null) {
+    throw new Error("No WebSocket implementation available.");
+  }
+  return WebSocketConstructor;
+}
+function toWebSocketUrl(url) {
+  const wsUrl = new URL(url);
+  if (wsUrl.protocol === "http:") {
+    wsUrl.protocol = "ws:";
+  } else if (wsUrl.protocol === "https:") {
+    wsUrl.protocol = "wss:";
+  }
+  return wsUrl;
+}
+var textDecoder = new TextDecoder();
+async function readWebSocketMessageText(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof ArrayBuffer) return textDecoder.decode(data);
+  if (ArrayBuffer.isView(data)) {
+    return textDecoder.decode(data);
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return data.text();
+  }
+  return String(data);
+}
+var WEBSOCKET_OPEN_STATE = 1;
+async function waitForWebSocketBufferDrain(socket, {
+  highWaterMark = 1024 * 1024,
+  pollIntervalMs = 20,
+  abortSignal
+} = {}) {
+  var _a2;
+  while (socket.readyState === WEBSOCKET_OPEN_STATE && ((_a2 = socket.bufferedAmount) != null ? _a2 : 0) > highWaterMark) {
+    if ((abortSignal == null ? void 0 : abortSignal.aborted) === true) {
+      return;
+    }
+    await delay(pollIntervalMs);
+  }
+}
+
+// src/connect-to-websocket.ts
+function connectToWebSocket({
+  url,
+  protocols,
+  headers,
+  webSocket,
+  abortSignal,
+  onOpen,
+  onMessageText,
+  onProcessingError,
+  onSocketError,
+  onClose,
+  onAbort
+}) {
+  var _a2;
+  let socket;
+  let abortListener;
+  const close = (code) => {
+    if (abortListener != null) {
+      abortSignal == null ? void 0 : abortSignal.removeEventListener("abort", abortListener);
+      abortListener = void 0;
+    }
+    try {
+      socket == null ? void 0 : socket.close(code);
+    } catch (e) {
+    }
+  };
+  if (abortSignal == null ? void 0 : abortSignal.aborted) {
+    onAbort == null ? void 0 : onAbort((_a2 = abortSignal.reason) != null ? _a2 : new Error("Aborted"));
+    return { socket: void 0, close };
+  }
+  try {
+    const WebSocketConstructor = getWebSocketConstructor(webSocket);
+    socket = new WebSocketConstructor(url, protocols, {
+      headers: removeUndefinedEntries(headers != null ? headers : {})
+    });
+  } catch (error) {
+    onProcessingError(error);
+    return { socket: void 0, close };
+  }
+  if (abortSignal != null && onAbort != null) {
+    abortListener = () => {
+      var _a3;
+      return onAbort((_a3 = abortSignal.reason) != null ? _a3 : new Error("Aborted"));
+    };
+    abortSignal.addEventListener("abort", abortListener, { once: true });
+  }
+  const openedSocket = socket;
+  socket.onopen = () => {
+    try {
+      onOpen == null ? void 0 : onOpen(openedSocket);
+    } catch (error) {
+      onProcessingError(error);
+    }
+  };
+  let tail = Promise.resolve();
+  socket.onmessage = (event) => {
+    tail = tail.then(() => readWebSocketMessageText(event.data)).then((text) => onMessageText(text)).catch(onProcessingError);
+  };
+  socket.onerror = () => {
+    tail = tail.then(() => onSocketError == null ? void 0 : onSocketError()).catch(onProcessingError);
+  };
+  socket.onclose = () => {
+    tail = tail.then(() => onClose == null ? void 0 : onClose()).catch(onProcessingError);
+  };
+  return { socket, close };
+}
+
 // src/convert-async-iterator-to-readable-stream.ts
 function convertAsyncIteratorToReadableStream(iterator) {
   let cancelled = false;
@@ -140,36 +289,6 @@ function createToolNameMapping({
   };
 }
 
-// src/delay.ts
-async function delay(delayInMs, options) {
-  if (delayInMs == null) {
-    return Promise.resolve();
-  }
-  const signal = options == null ? void 0 : options.abortSignal;
-  return new Promise((resolve2, reject) => {
-    if (signal == null ? void 0 : signal.aborted) {
-      reject(createAbortError());
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      cleanup();
-      resolve2();
-    }, delayInMs);
-    const cleanup = () => {
-      clearTimeout(timeoutId);
-      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
-    };
-    const onAbort = () => {
-      cleanup();
-      reject(createAbortError());
-    };
-    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
-  });
-}
-function createAbortError() {
-  return new DOMException("Delay was aborted", "AbortError");
-}
-
 // src/delayed-promise.ts
 var DelayedPromise = class {
   constructor() {
@@ -528,6 +647,51 @@ function isBrowserRuntime(globalThisAny = globalThis) {
   return globalThisAny.window != null;
 }
 
+// src/is-same-origin.ts
+function isSameOrigin(url, baseUrl) {
+  try {
+    return new URL(url).origin === new URL(baseUrl).origin;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/sanitize-request-headers.ts
+var BLOCKED_REQUEST_HEADERS = [
+  // Hop-by-hop / transport (RFC 7230 §6.1)
+  "connection",
+  "keep-alive",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  // Host / virtual-host routing
+  "host",
+  // Proxy / origin spoofing
+  "forwarded",
+  "proxy-authorization",
+  "via",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-real-ip",
+  // Cloud metadata (GCP, AWS IMDSv1/v2, Azure, Alibaba, DigitalOcean)
+  "metadata",
+  "metadata-flavor",
+  "x-aws-ec2-metadata-token",
+  "x-metadata-token",
+  // Session / cookie
+  "cookie",
+  "set-cookie"
+];
+function sanitizeRequestHeaders(input) {
+  const headers = new Headers(input);
+  for (const name2 of BLOCKED_REQUEST_HEADERS) {
+    headers.delete(name2);
+  }
+  return headers;
+}
+
 // src/validate-download-url.ts
 function validateDownloadUrl(url) {
   let parsed;
@@ -599,9 +763,12 @@ function isPrivateIPv4(ip) {
   if (a === 169 && b === 254) return true;
   if (a === 172 && b >= 16 && b <= 31) return true;
   if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 192 && b === 0 && c === 2) return true;
   if (a === 192 && b === 168) return true;
   if (a === 198 && (b === 18 || b === 19)) return true;
-  if (a >= 240) return true;
+  if (a === 198 && b === 51 && c === 100) return true;
+  if (a === 203 && b === 0 && c === 113) return true;
+  if (a >= 224) return true;
   return false;
 }
 function parseIPv6(ip) {
@@ -649,6 +816,8 @@ function isPrivateIPv6(ip) {
   if ((groups[0] & 65472) === 65152) return true;
   if ((groups[0] & 65472) === 65216) return true;
   if ((groups[0] & 65280) === 65280) return true;
+  if (groups[0] === 8193 && groups[1] === 3512) return true;
+  if (groups[0] === 16383 && (groups[1] & 61440) === 0) return true;
   const embedsIPv4 = (
     // ::/96 — IPv4-compatible (deprecated)
     topZero(6) || // ::ffff:0:0/96 — IPv4-mapped (ffff in group 5)
@@ -669,23 +838,29 @@ function isPrivateIPv6(ip) {
 
 // src/fetch-with-validated-redirects.ts
 var MAX_DOWNLOAD_REDIRECTS = 10;
+var REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 async function fetchWithValidatedRedirects({
   url,
   headers,
   abortSignal,
-  maxRedirects = MAX_DOWNLOAD_REDIRECTS
+  maxRedirects = MAX_DOWNLOAD_REDIRECTS,
+  fetch = globalThis.fetch,
+  trustedOrigin
 }) {
-  const baseInit = { signal: abortSignal };
-  if (headers !== void 0) {
-    baseInit.headers = headers;
-  }
+  let currentHeaders = headers === void 0 ? void 0 : sanitizeRequestHeaders(headers);
+  const perHopInit = (redirect) => {
+    const init = { signal: abortSignal, redirect };
+    if (currentHeaders !== void 0) {
+      init.headers = new Headers(currentHeaders);
+    }
+    return init;
+  };
   let currentUrl = url;
   for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
-    validateDownloadUrl(currentUrl);
-    const response = await fetch(currentUrl, {
-      ...baseInit,
-      redirect: "manual"
-    });
+    if (trustedOrigin === void 0 || !isSameOrigin(currentUrl, trustedOrigin)) {
+      validateDownloadUrl(currentUrl);
+    }
+    const response = await fetch(currentUrl, perHopInit("manual"));
     if (response.type === "opaqueredirect") {
       if (!isBrowserRuntime()) {
         throw new DownloadError({
@@ -693,12 +868,19 @@ async function fetchWithValidatedRedirects({
           message: `Redirect from ${currentUrl} could not be validated and was blocked`
         });
       }
-      return await fetch(currentUrl, { ...baseInit, redirect: "follow" });
+      return await fetch(currentUrl, perHopInit("follow"));
     }
     const location = response.headers.get("location");
-    if (response.status >= 300 && response.status < 400 && location) {
+    if (REDIRECT_STATUS_CODES.has(response.status) && location) {
       await cancelResponseBody(response);
-      currentUrl = new URL(location, currentUrl).toString();
+      const nextUrl = new URL(location, currentUrl).toString();
+      if (currentHeaders !== void 0 && !isSameOrigin(nextUrl, currentUrl)) {
+        const userAgent = currentHeaders.get("user-agent");
+        currentHeaders = new Headers(
+          userAgent == null ? void 0 : { "user-agent": userAgent }
+        );
+      }
+      currentUrl = nextUrl;
       continue;
     }
     return response;
@@ -971,7 +1153,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.6" : "0.0.0-test";
+var VERSION = true ? "5.0.9" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -981,16 +1163,27 @@ var getFromApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch: fetch2 = getOriginalFetch()
+  fetch = getOriginalFetch(),
+  validateUrl,
+  credentialedOrigin,
+  trustedOrigin
 }) => {
   try {
-    const response = await fetch2(url, {
+    const outgoingHeaders = credentialedOrigin !== void 0 && !isSameOrigin(url, credentialedOrigin) ? {} : headers;
+    const requestHeaders = withUserAgentSuffix(
+      outgoingHeaders,
+      `ai-sdk/provider-utils/${VERSION}`,
+      getRuntimeEnvironmentUserAgent()
+    );
+    const response = validateUrl ? await fetchWithValidatedRedirects({
+      url,
+      headers: requestHeaders,
+      abortSignal,
+      fetch,
+      trustedOrigin
+    }) : await fetch(url, {
       method: "GET",
-      headers: withUserAgentSuffix(
-        headers,
-        `ai-sdk/provider-utils/${VERSION}`,
-        getRuntimeEnvironmentUserAgent()
-      ),
+      headers: requestHeaders,
       signal: abortSignal
     });
     const responseHeaders = extractResponseHeaders(response);
@@ -1088,15 +1281,6 @@ function isBuffer(value) {
   return (_b2 = (_a2 = globalThis.Buffer) == null ? void 0 : _a2.isBuffer(value)) != null ? _b2 : false;
 }
 
-// src/is-same-origin.ts
-function isSameOrigin(url, baseUrl) {
-  try {
-    return new URL(url).origin === new URL(baseUrl).origin;
-  } catch (e) {
-    return false;
-  }
-}
-
 // src/is-non-nullable.ts
 function isNonNullable(value) {
   return value != null;
@@ -2814,7 +2998,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }) => await postToApi({
   url,
   headers: {
@@ -2828,7 +3012,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 });
 var postFormDataToApi = async ({
   url,
@@ -2837,7 +3021,7 @@ var postFormDataToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }) => await postToApi({
   url,
   headers,
@@ -2848,7 +3032,7 @@ var postFormDataToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 });
 var postToApi = async ({
   url,
@@ -2857,10 +3041,10 @@ var postToApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch: fetch2 = getOriginalFetch2()
+  fetch = getOriginalFetch2()
 }) => {
   try {
-    const response = await fetch2(url, {
+    const response = await fetch(url, {
       method: "POST",
       headers: withUserAgentSuffix(
         headers,
@@ -3012,13 +3196,6 @@ function createProviderExecutedToolFactory({
   });
 }
 
-// src/remove-undefined-entries.ts
-function removeUndefinedEntries(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter(([_key, value]) => value != null)
-  );
-}
-
 // src/resolve.ts
 async function resolve(value) {
   if (typeof value === "function") {
@@ -3153,12 +3330,12 @@ async function retryWithExponentialBackoffInternal(f, {
 
 // src/response-handler.ts
 import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
-var textDecoder = new TextDecoder();
+var textDecoder2 = new TextDecoder();
 async function readResponseBodyAsText({
   response,
   url
 }) {
-  return textDecoder.decode(
+  return textDecoder2.decode(
     await readResponseWithSizeLimit({
       response,
       url
@@ -3481,34 +3658,150 @@ function stripFileExtension(filename) {
   return firstDotIndex === -1 ? filename : filename.slice(0, firstDotIndex);
 }
 
-// src/websocket.ts
-function getWebSocketConstructor(webSocket) {
-  const WebSocketConstructor = webSocket != null ? webSocket : globalThis.WebSocket;
-  if (WebSocketConstructor == null) {
-    throw new Error("No WebSocket implementation available.");
+// src/transcription-stream-envelope.ts
+var TRANSCRIPTION_STREAM_START_FRAME_TYPE = "transcription-stream.start";
+var TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE = "transcription-stream.audio-done";
+function parseTranscriptionStreamClientFrame(text) {
+  let value;
+  try {
+    value = secureJsonParse(text);
+  } catch (e) {
+    return { type: "invalid", message: "malformed JSON" };
+  }
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return { type: "invalid", message: "frame must be a JSON object" };
+  }
+  const frame = value;
+  if (typeof frame.type !== "string") {
+    return { type: "invalid", message: "frame type must be a string" };
+  }
+  switch (frame.type) {
+    case TRANSCRIPTION_STREAM_START_FRAME_TYPE: {
+      const inputAudioFormat = frame.inputAudioFormat;
+      if (inputAudioFormat == null || typeof inputAudioFormat !== "object" || Array.isArray(inputAudioFormat) || typeof inputAudioFormat.type !== "string") {
+        return {
+          type: "invalid",
+          message: "start frame must have an inputAudioFormat object with a string type"
+        };
+      }
+      if (inputAudioFormat.rate !== void 0 && typeof inputAudioFormat.rate !== "number") {
+        return {
+          type: "invalid",
+          message: "inputAudioFormat.rate must be a number when present"
+        };
+      }
+      if (frame.providerOptions !== void 0 && (frame.providerOptions == null || typeof frame.providerOptions !== "object" || Array.isArray(frame.providerOptions))) {
+        return {
+          type: "invalid",
+          message: "providerOptions must be an object when present"
+        };
+      }
+      if (frame.includeRawChunks !== void 0 && typeof frame.includeRawChunks !== "boolean") {
+        return {
+          type: "invalid",
+          message: "includeRawChunks must be a boolean when present"
+        };
+      }
+      return {
+        type: "start",
+        frame
+      };
+    }
+    case TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE:
+      return { type: "audio-done" };
+    default:
+      return { type: "unknown" };
   }
-  return WebSocketConstructor;
 }
-function toWebSocketUrl(url) {
-  const wsUrl = new URL(url);
-  if (wsUrl.protocol === "http:") {
-    wsUrl.protocol = "ws:";
-  } else if (wsUrl.protocol === "https:") {
-    wsUrl.protocol = "wss:";
+function serializeTranscriptionStreamPart(part) {
+  try {
+    if (part.type === "error" && isError(part.error)) {
+      return JSON.stringify({
+        ...part,
+        error: { name: part.error.name, message: part.error.message }
+      });
+    }
+    return JSON.stringify(part);
+  } catch (e) {
+    return void 0;
   }
-  return wsUrl;
 }
-var textDecoder2 = new TextDecoder();
-async function readWebSocketMessageText(data) {
-  if (typeof data === "string") return data;
-  if (data instanceof ArrayBuffer) return textDecoder2.decode(data);
-  if (ArrayBuffer.isView(data)) {
-    return textDecoder2.decode(data);
+function isError(value) {
+  return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
+}
+function parseTranscriptionStreamPart(text) {
+  let value;
+  try {
+    value = secureJsonParse(text);
+  } catch (e) {
+    return void 0;
   }
-  if (typeof Blob !== "undefined" && data instanceof Blob) {
-    return data.text();
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
   }
-  return String(data);
+  const part = value;
+  switch (part.type) {
+    case "stream-start":
+      return Array.isArray(part.warnings) && part.warnings.every(isWarning) ? part : void 0;
+    case "transcript-delta":
+      return isString(part.delta) && isOptional(part.id, isString) && isOptional(part.providerMetadata, isPlainObject) ? part : void 0;
+    case "transcript-partial":
+      return isString(part.text) && isOptional(part.id, isString) && isOptional(part.startSecond, isNumber) && isOptional(part.durationInSeconds, isNumber) && isOptional(part.channelIndex, isNumber) && isOptional(part.providerMetadata, isPlainObject) ? part : void 0;
+    case "transcript-final":
+      return isString(part.text) && isOptional(part.id, isString) && isOptional(part.startSecond, isNumber) && isOptional(part.endSecond, isNumber) && isOptional(part.channelIndex, isNumber) && isOptional(part.providerMetadata, isPlainObject) ? part : void 0;
+    case "finish":
+      return isString(part.text) && Array.isArray(part.segments) && part.segments.every(isSegment) && isOptional(part.language, isString) && isOptional(part.durationInSeconds, isNumber) && isOptional(part.providerMetadata, isPlainObject) ? part : void 0;
+    case "response-metadata": {
+      if (!(isOptional(part.modelId, isString) && isOptional(part.headers, isPlainObject))) {
+        return void 0;
+      }
+      const timestamp = part.timestamp;
+      if (timestamp == null) {
+        return { ...part, timestamp: void 0 };
+      }
+      if (typeof timestamp !== "string") {
+        return void 0;
+      }
+      const revived = new Date(timestamp);
+      return Number.isNaN(revived.getTime()) ? void 0 : { ...part, timestamp: revived };
+    }
+    case "raw":
+      return "rawValue" in part ? part : void 0;
+    case "error":
+      return "error" in part ? part : void 0;
+    default:
+      return void 0;
+  }
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isOptional(value, check) {
+  return value === void 0 || check(value);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function isWarning(value) {
+  return isPlainObject(value) && isString(value.type);
+}
+function isSegment(value) {
+  return isPlainObject(value) && isString(value.text) && isNumber(value.startSecond) && isNumber(value.endSecond);
+}
+
+// src/validate-base-url.ts
+import { InvalidArgumentError as InvalidArgumentError3 } from "@ai-sdk/provider";
+function validateBaseURL(baseURL) {
+  if ((baseURL == null ? void 0 : baseURL.trim()) === "") {
+    throw new InvalidArgumentError3({
+      argument: "baseURL",
+      message: "baseURL must be a non-empty string."
+    });
+  }
+  return baseURL;
 }
 
 // src/without-trailing-slash.ts
@@ -3554,6 +3847,8 @@ export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
+  TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE,
+  TRANSCRIPTION_STREAM_START_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE,
   EventSourceParserStream2 as EventSourceParserStream,
   StreamingToolCallTracker,
   VERSION,
@@ -3563,6 +3858,7 @@ export {
   asSchema,
   cancelResponseBody,
   combineHeaders,
+  connectToWebSocket,
   convertAsyncIteratorToReadableStream,
   convertBase64ToUint8Array,
   convertImageModelFileToDataUri,
@@ -3585,6 +3881,9 @@ export {
   downloadBlob,
   dynamicTool,
   executeTool,
+  parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame,
+  parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart,
+  serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart,
   extractLines,
   extractResponseHeaders,
   fetchWithValidatedRedirects,
@@ -3636,8 +3935,10 @@ export {
   stripFileExtension,
   toWebSocketUrl,
   tool,
+  validateBaseURL,
   validateDownloadUrl,
   validateTypes,
+  waitForWebSocketBufferDrain,
   withUserAgentSuffix,
   withoutTrailingSlash,
   zodSchema