maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.64.20260929

package/node_modules/@ai-sdk/provider-utils/dist/index.js

@@ -8,7 +8,7 @@ function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => ({
       ...combinedHeaders,
-      ...currentHeaders != null ? currentHeaders : {}
+      ...currentHeaders
     }),
     {}
   );
@@ -24,11 +24,11 @@ function removeUndefinedEntries(record) {
 // src/delay.ts
 async function delay(delayInMs, options) {
   if (delayInMs == null) {
-    return Promise.resolve();
+    return;
   }
-  const signal = options == null ? void 0 : options.abortSignal;
+  const signal = options?.abortSignal;
   return new Promise((resolve2, reject) => {
-    if (signal == null ? void 0 : signal.aborted) {
+    if (signal?.aborted) {
       reject(createAbortError());
       return;
     }
@@ -38,13 +38,13 @@ async function delay(delayInMs, options) {
     }, delayInMs);
     const cleanup = () => {
       clearTimeout(timeoutId);
-      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+      signal?.removeEventListener("abort", onAbort);
     };
     const onAbort = () => {
       cleanup();
       reject(createAbortError());
     };
-    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
+    signal?.addEventListener("abort", onAbort);
   });
 }
 function createAbortError() {
@@ -53,7 +53,7 @@ function createAbortError() {
 
 // src/websocket.ts
 function getWebSocketConstructor(webSocket) {
-  const WebSocketConstructor = webSocket != null ? webSocket : globalThis.WebSocket;
+  const WebSocketConstructor = webSocket ?? globalThis.WebSocket;
   if (WebSocketConstructor == null) {
     throw new Error("No WebSocket implementation available.");
   }
@@ -86,9 +86,8 @@ async function waitForWebSocketBufferDrain(socket, {
   pollIntervalMs = 20,
   abortSignal
 } = {}) {
-  var _a3;
-  while (socket.readyState === WEBSOCKET_OPEN_STATE && ((_a3 = socket.bufferedAmount) != null ? _a3 : 0) > highWaterMark) {
-    if ((abortSignal == null ? void 0 : abortSignal.aborted) === true) {
+  while (socket.readyState === WEBSOCKET_OPEN_STATE && (socket.bufferedAmount ?? 0) > highWaterMark) {
+    if (abortSignal?.aborted === true) {
       return;
     }
     await delay(pollIntervalMs);
@@ -109,43 +108,39 @@ function connectToWebSocket({
   onClose,
   onAbort
 }) {
-  var _a3;
   let socket;
   let abortListener;
   const close = (code) => {
     if (abortListener != null) {
-      abortSignal == null ? void 0 : abortSignal.removeEventListener("abort", abortListener);
+      abortSignal?.removeEventListener("abort", abortListener);
       abortListener = void 0;
     }
     try {
-      socket == null ? void 0 : socket.close(code);
-    } catch (e) {
+      socket?.close(code);
+    } catch {
     }
   };
-  if (abortSignal == null ? void 0 : abortSignal.aborted) {
-    onAbort == null ? void 0 : onAbort((_a3 = abortSignal.reason) != null ? _a3 : new Error("Aborted"));
+  if (abortSignal?.aborted) {
+    onAbort?.(abortSignal.reason ?? new Error("Aborted"));
     return { socket: void 0, close };
   }
   try {
     const WebSocketConstructor = getWebSocketConstructor(webSocket);
     socket = new WebSocketConstructor(url, protocols, {
-      headers: removeUndefinedEntries(headers != null ? headers : {})
+      headers: removeUndefinedEntries(headers ?? {})
     });
   } catch (error) {
     onProcessingError(error);
     return { socket: void 0, close };
   }
   if (abortSignal != null && onAbort != null) {
-    abortListener = () => {
-      var _a4;
-      return onAbort((_a4 = abortSignal.reason) != null ? _a4 : new Error("Aborted"));
-    };
+    abortListener = () => onAbort(abortSignal.reason ?? new Error("Aborted"));
     abortSignal.addEventListener("abort", abortListener, { once: true });
   }
   const openedSocket = socket;
   socket.onopen = () => {
     try {
-      onOpen == null ? void 0 : onOpen(openedSocket);
+      onOpen?.(openedSocket);
     } catch (error) {
       onProcessingError(error);
     }
@@ -155,13 +150,13 @@ function connectToWebSocket({
     tail = tail.then(() => readWebSocketMessageText(event.data)).then((text) => onMessageText(text)).catch(onProcessingError);
   };
   socket.onerror = () => {
-    tail = tail.then(() => onSocketError == null ? void 0 : onSocketError()).catch(onProcessingError);
+    tail = tail.then(() => onSocketError?.()).catch(onProcessingError);
   };
   socket.onclose = (event) => {
     const closeEvent = event;
-    const code = typeof (closeEvent == null ? void 0 : closeEvent.code) === "number" ? closeEvent.code : void 0;
-    const reason = typeof (closeEvent == null ? void 0 : closeEvent.reason) === "string" ? closeEvent.reason : void 0;
-    tail = tail.then(() => onClose == null ? void 0 : onClose({ code, reason })).catch(onProcessingError);
+    const code = typeof closeEvent?.code === "number" ? closeEvent.code : void 0;
+    const reason = typeof closeEvent?.reason === "string" ? closeEvent.reason : void 0;
+    tail = tail.then(() => onClose?.({ code, reason })).catch(onProcessingError);
   };
   return { socket, close };
 }
@@ -197,13 +192,16 @@ function convertAsyncIteratorToReadableStream(iterator) {
       if (iterator.return) {
         try {
           await iterator.return(reason);
-        } catch (e) {
+        } catch {
         }
       }
     }
   });
 }
 
+// src/convert-inline-file-data-to-uint8-array.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+
 // src/uint8-utils.ts
 var { btoa, atob } = globalThis;
 function convertBase64ToUint8Array(base64String) {
@@ -212,11 +210,12 @@ function convertBase64ToUint8Array(base64String) {
   return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
 }
 function convertUint8ArrayToBase64(array) {
-  let latin1string = "";
-  for (let i = 0; i < array.length; i++) {
-    latin1string += String.fromCodePoint(array[i]);
+  const chunks = [];
+  const chunkSize = 4096;
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(String.fromCodePoint(...array.subarray(i, i + chunkSize)));
   }
-  return btoa(latin1string);
+  return btoa(chunks.join(""));
 }
 function convertToBase64(value) {
   return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
@@ -224,6 +223,14 @@ function convertToBase64(value) {
 
 // src/convert-inline-file-data-to-uint8-array.ts
 function convertInlineFileDataToUint8Array(data) {
+  if (data.type === "stream") {
+    const error = new UnsupportedFunctionalityError({
+      functionality: "streaming file upload"
+    });
+    void data.stream.cancel(error).catch(() => {
+    });
+    throw error;
+  }
   if (data.type === "text") {
     return new TextEncoder().encode(data.text);
   }
@@ -273,8 +280,8 @@ function createLanguageModelResponseMetadata({
   created
 }) {
   return {
-    id: id != null ? id : void 0,
-    modelId: model != null ? model : void 0,
+    id: id ?? void 0,
+    modelId: model ?? void 0,
     timestamp: created != null ? new Date(created * 1e3) : void 0
   };
 }
@@ -312,15 +319,34 @@ function createToolNameMapping({
     }
   }
   return {
-    toProviderToolName: (customToolName) => {
-      var _a3;
-      return (_a3 = customToolNameToProviderToolName[customToolName]) != null ? _a3 : customToolName;
-    },
-    toCustomToolName: (providerToolName) => {
-      var _a3;
-      return (_a3 = providerToolNameToCustomToolName[providerToolName]) != null ? _a3 : providerToolName;
-    }
+    toProviderToolName: (customToolName) => customToolNameToProviderToolName[customToolName] ?? customToolName,
+    toCustomToolName: (providerToolName) => providerToolNameToCustomToolName[providerToolName] ?? providerToolName
+  };
+}
+
+// src/create-provider-stream-error.ts
+var marker = /* @__PURE__ */ Symbol.for("vercel.ai.providerStreamError");
+function createProviderStreamError({
+  message,
+  type,
+  code,
+  statusCode,
+  isRetryable,
+  data
+}) {
+  const error = {
+    message,
+    type,
+    code,
+    statusCode,
+    isRetryable,
+    data
   };
+  Object.defineProperty(error, marker, { value: true });
+  return error;
+}
+function isProviderStreamError(error) {
+  return typeof error === "object" && error != null && error[marker] === true;
 }
 
 // src/delayed-promise.ts
@@ -346,17 +372,15 @@ var DelayedPromise = class {
     return this._promise;
   }
   resolve(value) {
-    var _a3;
     this.status = { type: "resolved", value };
     if (this._promise) {
-      (_a3 = this._resolve) == null ? void 0 : _a3.call(this, value);
+      this._resolve?.(value);
     }
   }
   reject(error) {
-    var _a3;
     this.status = { type: "rejected", error };
     if (this._promise) {
-      (_a3 = this._reject) == null ? void 0 : _a3.call(this, error);
+      this._reject?.(error);
     }
   }
   isResolved() {
@@ -370,12 +394,229 @@ var DelayedPromise = class {
   }
 };
 
+// src/delete-from-api.ts
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
+
+// src/extract-response-headers.ts
+function extractResponseHeaders(response) {
+  return Object.fromEntries([...response.headers]);
+}
+
+// src/get-runtime-environment-user-agent.ts
+function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
+  if (globalThisAny.navigator?.userAgent) {
+    return globalThisAny.navigator.userAgent.toLowerCase();
+  }
+  if (globalThisAny.process?.versions?.node) {
+    return `node.js/${globalThisAny.process.version}`;
+  }
+  if (globalThisAny.EdgeRuntime) {
+    return "vercel-edge";
+  }
+  return "";
+}
+
+// src/handle-fetch-error.ts
+import { APICallError } from "@ai-sdk/provider";
+
+// src/is-abort-error.ts
+function isAbortError(error) {
+  return (error instanceof Error || typeof DOMException === "function" && error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
+  error.name === "TimeoutError");
+}
+
+// src/handle-fetch-error.ts
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+function findNetworkError(error) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error && !visited.has(current)) {
+    visited.add(current);
+    const errorWithCode = current;
+    if (typeof errorWithCode.code === "string" && RETRYABLE_NETWORK_ERROR_CODES.has(errorWithCode.code)) {
+      return errorWithCode;
+    }
+    current = current.cause;
+  }
+}
+function handleFetchError({
+  error,
+  url,
+  requestBodyValues
+}) {
+  if (isAbortError(error)) {
+    return error;
+  }
+  if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
+    const cause = error.cause;
+    if (cause != null) {
+      return new APICallError({
+        message: `Cannot connect to API: ${cause.message}`,
+        cause,
+        url,
+        requestBodyValues,
+        isRetryable: true
+        // retry when network error
+      });
+    }
+  }
+  const networkError = findNetworkError(error);
+  if (networkError != null) {
+    if (APICallError.isInstance(error)) {
+      return new APICallError({
+        message: error.message,
+        cause: error.cause,
+        url: error.url,
+        requestBodyValues: error.requestBodyValues,
+        statusCode: error.statusCode,
+        responseHeaders: error.responseHeaders,
+        responseBody: error.responseBody,
+        data: error.data,
+        isRetryable: true
+      });
+    }
+    return new APICallError({
+      message: `Cannot connect to API: ${error instanceof Error ? error.message : networkError.message}`,
+      cause: error,
+      url,
+      requestBodyValues,
+      isRetryable: true
+    });
+  }
+  return error;
+}
+
+// src/version.ts
+var VERSION = true ? "5.0.51" : "0.0.0-test";
+
+// src/normalize-headers.ts
+function normalizeHeaders(headers) {
+  if (headers == null) {
+    return {};
+  }
+  const normalized = {};
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      normalized[key.toLowerCase()] = value;
+    });
+  } else {
+    if (!Array.isArray(headers)) {
+      headers = Object.entries(headers);
+    }
+    for (const [key, value] of headers) {
+      if (value != null) {
+        normalized[key.toLowerCase()] = value;
+      }
+    }
+  }
+  return normalized;
+}
+
+// src/with-user-agent-suffix.ts
+function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
+  const normalizedHeaders = new Headers(normalizeHeaders(headers));
+  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
+  normalizedHeaders.set(
+    "user-agent",
+    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
+  );
+  return Object.fromEntries(normalizedHeaders.entries());
+}
+
+// src/delete-from-api.ts
+var getOriginalFetch = () => globalThis.fetch;
+var deleteFromApi = async ({
+  url,
+  headers = {},
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch = getOriginalFetch()
+}) => {
+  try {
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: withUserAgentSuffix(
+        headers,
+        `ai-sdk-provider-utils/${VERSION}`,
+        getRuntimeEnvironmentUserAgent()
+      ),
+      signal: abortSignal
+    });
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url,
+          requestBodyValues: {}
+        });
+      } catch (error) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
+          throw error;
+        }
+        throw new APICallError2({
+          message: "Failed to process error response",
+          cause: error,
+          statusCode: response.status,
+          url,
+          responseHeaders,
+          requestBodyValues: {}
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url,
+        requestBodyValues: {}
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
+          throw error;
+        }
+      }
+      throw new APICallError2({
+        message: "Failed to process successful response",
+        cause: error,
+        statusCode: response.status,
+        url,
+        responseHeaders,
+        requestBodyValues: {}
+      });
+    }
+  } catch (error) {
+    throw handleFetchError({ error, url, requestBodyValues: {} });
+  }
+};
+
 // src/detect-media-type.ts
 var imageMediaTypeSignatures = [
   {
     mediaType: "image/gif",
-    bytesPrefix: [71, 73, 70]
-    // GIF
+    bytesPrefix: [71, 73, 70, 56, 55, 97]
+    // GIF87a
+  },
+  {
+    mediaType: "image/gif",
+    bytesPrefix: [71, 73, 70, 56, 57, 97]
+    // GIF89a
   },
   {
     mediaType: "image/png",
@@ -409,7 +650,7 @@ var imageMediaTypeSignatures = [
   },
   {
     mediaType: "image/bmp",
-    bytesPrefix: [66, 77]
+    bytesPrefix: [66, 77, null, null, null, null, 0, 0, 0, 0]
   },
   {
     mediaType: "image/tiff",
@@ -425,7 +666,8 @@ var imageMediaTypeSignatures = [
       0,
       0,
       0,
-      32,
+      null,
+      // box size (variable)
       102,
       116,
       121,
@@ -442,7 +684,8 @@ var imageMediaTypeSignatures = [
       0,
       0,
       0,
-      32,
+      null,
+      // box size (variable)
       102,
       116,
       121,
@@ -462,6 +705,26 @@ var documentMediaTypeSignatures = [
   }
 ];
 var audioMediaTypeSignaturesWithoutMp4 = [
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [255, 240]
+    // MPEG-4 ADTS with CRC
+  },
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [255, 241]
+    // MPEG-4 ADTS without CRC
+  },
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [255, 248]
+    // MPEG-2 ADTS with CRC
+  },
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [255, 249]
+    // MPEG-2 ADTS without CRC
+  },
   {
     mediaType: "audio/mpeg",
     bytesPrefix: [255, 251]
@@ -625,7 +888,6 @@ function detectMediaTypeBySignatures({
       return signature.mediaType;
     }
   }
-  return void 0;
 }
 var topLevelSignatureTables = {
   image: imageMediaTypeSignatures,
@@ -671,18 +933,17 @@ function isFullMediaType(mediaType) {
 
 // src/cancel-response-body.ts
 async function cancelResponseBody(response) {
-  var _a3;
   try {
-    await ((_a3 = response.body) == null ? void 0 : _a3.cancel());
-  } catch (e) {
+    await response.body?.cancel();
+  } catch {
   }
 }
 
 // src/download-error.ts
 import { AISDKError } from "@ai-sdk/provider";
 var name = "AI_DownloadError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
+var marker2 = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker2);
 var _a, _b;
 var DownloadError = class extends (_b = AISDKError, _a = symbol, _b) {
   constructor({
@@ -699,7 +960,7 @@ var DownloadError = class extends (_b = AISDKError, _a = symbol, _b) {
     this.statusText = statusText;
   }
   static isInstance(error) {
-    return AISDKError.hasMarker(error, marker);
+    return AISDKError.hasMarker(error, marker2);
   }
 };
 
@@ -712,7 +973,7 @@ function isBrowserRuntime(globalThisAny = globalThis) {
 function isSameOrigin(url, baseUrl) {
   try {
     return new URL(url).origin === new URL(baseUrl).origin;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
@@ -722,7 +983,7 @@ function validateDownloadUrl(url) {
   let parsed;
   try {
     parsed = new URL(url);
-  } catch (e) {
+  } catch {
     throw new DownloadError({
       url,
       message: `Invalid URL: ${url}`
@@ -767,7 +1028,6 @@ function validateDownloadUrl(url) {
         message: `URL with IP address ${hostname} is not allowed`
       });
     }
-    return;
   }
 }
 function validateDownloadAddress({
@@ -908,32 +1168,21 @@ function createSafeLookup(lookup) {
   });
 }
 var safeNodeFetchPromise;
-var initialGlobalFetch = globalThis.fetch;
-var initialGlobalFetchIsNodeDefault = isNodeDefaultFetch(initialGlobalFetch);
 function isNodeRuntime() {
-  var _a3, _b3;
   const runtimeProcess = globalThis.process;
-  return ((_a3 = runtimeProcess == null ? void 0 : runtimeProcess.release) == null ? void 0 : _a3.name) === "node" && ((_b3 = runtimeProcess.versions) == null ? void 0 : _b3.bun) == null;
+  return runtimeProcess?.release?.name === "node" && runtimeProcess.versions?.bun == null && runtimeProcess.versions?.deno == null && runtimeProcess.title !== "workerd" && globalThis.EdgeRuntime == null;
 }
 async function getDefaultDownloadFetch() {
-  if (!isNodeRuntime() || !initialGlobalFetchIsNodeDefault || globalThis.fetch !== initialGlobalFetch) {
+  if (!isNodeRuntime()) {
     return globalThis.fetch;
   }
-  return safeNodeFetchPromise != null ? safeNodeFetchPromise : safeNodeFetchPromise = Promise.resolve().then(createSafeNodeFetch);
-}
-function isNodeDefaultFetch(fetch) {
-  if (typeof fetch !== "function") {
-    return false;
-  }
-  const source = Function.prototype.toString.call(fetch);
-  return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
+  return safeNodeFetchPromise ??= Promise.resolve().then(createSafeNodeFetch);
 }
 function createSafeNodeFetch() {
-  const { createRequire } = loadBuiltinModule("node:module");
+  const module = loadBuiltinModule("node:module");
   const { lookup } = loadBuiltinModule("node:dns");
-  const { Agent, fetch } = createRequire(getCurrentModulePath())(
-    "undici"
-  );
+  const nodeRequire = module.createRequire(getCurrentModulePath());
+  const { Agent, fetch } = nodeRequire("undici");
   const dispatcher = new Agent({
     connect: {
       lookup: createSafeLookup(lookup)
@@ -948,9 +1197,8 @@ function createSafeNodeFetch() {
   ));
 }
 function loadBuiltinModule(id) {
-  var _a3;
   const processWithBuiltins = globalThis.process;
-  const builtinModule = (_a3 = processWithBuiltins == null ? void 0 : processWithBuiltins.getBuiltinModule) == null ? void 0 : _a3.call(processWithBuiltins, id);
+  const builtinModule = processWithBuiltins?.getBuiltinModule?.(id);
   if (builtinModule == null) {
     throw new Error(`Node.js built-in module ${id} is unavailable`);
   }
@@ -963,7 +1211,7 @@ function getCurrentModulePath() {
     const error = new Error("Capture current module path");
     Error.captureStackTrace(error, getCurrentModulePath);
     const [caller] = error.stack;
-    const fileName = caller == null ? void 0 : caller.getFileName();
+    const fileName = caller?.getFileName();
     if (fileName == null) {
       throw new Error("Unable to determine the current module path");
     }
@@ -1012,6 +1260,27 @@ function sanitizeRequestHeaders(input) {
 // 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 getValidatedFetch(customFetch) {
+  return customFetch == null || customFetch === globalThis.fetch ? await getDefaultDownloadFetch() : customFetch;
+}
+async function fetchWithValidatedEndpoint({
+  url,
+  init,
+  fetch: customFetch,
+  trustedOrigin,
+  redirect = "error"
+}) {
+  const urlText = url.toString();
+  const isTrusted = trustedOrigin !== void 0 && isSameOrigin(urlText, trustedOrigin);
+  if (!isTrusted) {
+    validateDownloadUrl(urlText);
+  }
+  const fetch = isTrusted && customFetch != null ? customFetch : isTrusted ? globalThis.fetch : await getValidatedFetch(customFetch);
+  return await fetch(url, {
+    ...init,
+    redirect
+  });
+}
 async function fetchWithValidatedRedirects({
   url,
   headers,
@@ -1034,7 +1303,7 @@ async function fetchWithValidatedRedirects({
     if (!isTrustedHop) {
       validateDownloadUrl(currentUrl);
     }
-    const fetch = customFetch != null ? customFetch : isTrustedHop ? globalThis.fetch : await getDefaultDownloadFetch();
+    const fetch = isTrustedHop && customFetch != null ? customFetch : isTrustedHop ? globalThis.fetch : await getValidatedFetch(customFetch);
     const response = await fetch(currentUrl, perHopInit("manual"));
     if (response.type === "opaqueredirect") {
       if (!isBrowserRuntime()) {
@@ -1045,9 +1314,9 @@ async function fetchWithValidatedRedirects({
       }
       return await fetch(currentUrl, perHopInit("follow"));
     }
-    const location = response.headers.get("location");
+    const location = response.headers?.get("location");
     if (REDIRECT_STATUS_CODES.has(response.status) && location) {
-      await cancelResponseBody(response);
+      void cancelResponseBody(response);
       const nextUrl = new URL(location, currentUrl).toString();
       if (currentHeaders !== void 0 && !isSameOrigin(nextUrl, currentUrl)) {
         const userAgent = currentHeaders.get("user-agent");
@@ -1066,6 +1335,52 @@ async function fetchWithValidatedRedirects({
   });
 }
 
+// src/fetch-untrusted-url.ts
+var SAFE_UNTRUSTED_FIRST_HOP_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-language",
+  "baggage",
+  "cache-control",
+  "idempotency-key",
+  "if-match",
+  "if-modified-since",
+  "if-none-match",
+  "if-range",
+  "if-unmodified-since",
+  "pragma",
+  "range",
+  "traceparent",
+  "tracestate",
+  "user-agent",
+  "x-correlation-id",
+  "x-request-id"
+]);
+async function fetchUntrustedUrl({
+  headers,
+  credentialedOrigin,
+  untrustedFirstHopHeaders,
+  ...options
+}) {
+  let firstHopHeaders;
+  if (headers !== void 0) {
+    firstHopHeaders = sanitizeRequestHeaders(headers);
+    const origin = credentialedOrigin ?? options.trustedOrigin;
+    if (origin === void 0 || !isSameOrigin(options.url, origin)) {
+      const allowedHeaders = /* @__PURE__ */ new Set([
+        ...SAFE_UNTRUSTED_FIRST_HOP_HEADERS,
+        ...(untrustedFirstHopHeaders ?? []).map((name3) => name3.toLowerCase())
+      ]);
+      firstHopHeaders = new Headers(
+        [...firstHopHeaders].filter(([name3]) => allowedHeaders.has(name3))
+      );
+    }
+  }
+  return fetchWithValidatedRedirects({
+    ...options,
+    headers: firstHopHeaders
+  });
+}
+
 // src/read-response-with-size-limit.ts
 var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
 async function readResponseWithSizeLimit({
@@ -1109,7 +1424,7 @@ async function readResponseWithSizeLimit({
   } finally {
     try {
       await reader.cancel();
-    } catch (e) {
+    } catch {
     } finally {
       reader.releaseLock();
     }
@@ -1125,11 +1440,10 @@ async function readResponseWithSizeLimit({
 
 // src/download-blob.ts
 async function downloadBlob(url, options) {
-  var _a3, _b3;
   try {
-    const response = await fetchWithValidatedRedirects({
+    const response = await fetchUntrustedUrl({
       url,
-      abortSignal: options == null ? void 0 : options.abortSignal
+      abortSignal: options?.abortSignal
     });
     if (!response.ok) {
       await cancelResponseBody(response);
@@ -1142,9 +1456,9 @@ async function downloadBlob(url, options) {
     const data = await readResponseWithSizeLimit({
       response,
       url,
-      maxBytes: (_a3 = options == null ? void 0 : options.maxBytes) != null ? _a3 : DEFAULT_MAX_DOWNLOAD_SIZE
+      maxBytes: options?.maxBytes ?? DEFAULT_MAX_DOWNLOAD_SIZE
     });
-    const contentType = (_b3 = response.headers.get("content-type")) != null ? _b3 : void 0;
+    const contentType = response.headers.get("content-type") ?? void 0;
     return new Blob([data], contentType ? { type: contentType } : void 0);
   } catch (error) {
     if (DownloadError.isInstance(error)) {
@@ -1154,6 +1468,14 @@ async function downloadBlob(url, options) {
   }
 }
 
+// src/embedding-model-capabilities.ts
+var EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL = /* @__PURE__ */ Symbol.for(
+  "vercel.ai.embeddingModel.maxInputBytesPerCall"
+);
+var EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER = /* @__PURE__ */ Symbol.for(
+  "vercel.ai.embeddingModel.providerOptionsTransformer"
+);
+
 // src/extract-lines.ts
 function extractLines({
   text,
@@ -1163,16 +1485,11 @@ function extractLines({
   if (startLine == null && endLine == null) return text;
   const lineEnding = text.includes("\r\n") ? "\r\n" : text.includes("\n") ? "\n" : text.includes("\r") ? "\r" : "\n";
   const lines = text.split(lineEnding);
-  const start = Math.max(1, startLine != null ? startLine : 1) - 1;
-  const end = Math.min(lines.length, endLine != null ? endLine : lines.length);
+  const start = Math.max(1, startLine ?? 1) - 1;
+  const end = Math.min(lines.length, endLine ?? lines.length);
   return lines.slice(start, end).join(lineEnding);
 }
 
-// src/extract-response-headers.ts
-function extractResponseHeaders(response) {
-  return Object.fromEntries([...response.headers]);
-}
-
 // src/filter-nullable.ts
 function filterNullable(...values) {
   return values.filter((value) => value != null);
@@ -1211,128 +1528,8 @@ var generateId = createIdGenerator();
 import { getErrorMessage } from "@ai-sdk/provider";
 
 // src/get-from-api.ts
-import { APICallError as APICallError2 } from "@ai-sdk/provider";
-
-// src/handle-fetch-error.ts
-import { APICallError } from "@ai-sdk/provider";
-
-// src/is-abort-error.ts
-function isAbortError(error) {
-  return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
-  error.name === "TimeoutError");
-}
-
-// src/handle-fetch-error.ts
-var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
-var BUN_ERROR_CODES = [
-  "ConnectionRefused",
-  "ConnectionClosed",
-  "FailedToOpenSocket",
-  "ECONNRESET",
-  "ECONNREFUSED",
-  "ETIMEDOUT",
-  "EPIPE"
-];
-function isBunNetworkError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  const code = error.code;
-  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
-    return true;
-  }
-  return false;
-}
-function handleFetchError({
-  error,
-  url,
-  requestBodyValues
-}) {
-  if (isAbortError(error)) {
-    return error;
-  }
-  if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
-    const cause = error.cause;
-    if (cause != null) {
-      return new APICallError({
-        message: `Cannot connect to API: ${cause.message}`,
-        cause,
-        url,
-        requestBodyValues,
-        isRetryable: true
-        // retry when network error
-      });
-    }
-  }
-  if (isBunNetworkError(error)) {
-    return new APICallError({
-      message: `Cannot connect to API: ${error.message}`,
-      cause: error,
-      url,
-      requestBodyValues,
-      isRetryable: true
-    });
-  }
-  return error;
-}
-
-// src/get-runtime-environment-user-agent.ts
-function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
-  var _a3, _b3, _c;
-  if (globalThisAny.window) {
-    return `runtime/browser`;
-  }
-  if ((_a3 = globalThisAny.navigator) == null ? void 0 : _a3.userAgent) {
-    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
-  }
-  if ((_c = (_b3 = globalThisAny.process) == null ? void 0 : _b3.versions) == null ? void 0 : _c.node) {
-    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
-  }
-  if (globalThisAny.EdgeRuntime) {
-    return `runtime/vercel-edge`;
-  }
-  return "runtime/unknown";
-}
-
-// src/normalize-headers.ts
-function normalizeHeaders(headers) {
-  if (headers == null) {
-    return {};
-  }
-  const normalized = {};
-  if (headers instanceof Headers) {
-    headers.forEach((value, key) => {
-      normalized[key.toLowerCase()] = value;
-    });
-  } else {
-    if (!Array.isArray(headers)) {
-      headers = Object.entries(headers);
-    }
-    for (const [key, value] of headers) {
-      if (value != null) {
-        normalized[key.toLowerCase()] = value;
-      }
-    }
-  }
-  return normalized;
-}
-
-// src/with-user-agent-suffix.ts
-function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
-  const normalizedHeaders = new Headers(normalizeHeaders(headers));
-  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
-  normalizedHeaders.set(
-    "user-agent",
-    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
-  );
-  return Object.fromEntries(normalizedHeaders.entries());
-}
-
-// src/version.ts
-var VERSION = true ? "5.0.28" : "0.0.0-test";
-
-// src/get-from-api.ts
-var getOriginalFetch = () => globalThis.fetch;
+import { APICallError as APICallError3 } from "@ai-sdk/provider";
+var getOriginalFetch2 = () => globalThis.fetch;
 var getFromApi = async ({
   url,
   headers = {},
@@ -1345,11 +1542,11 @@ var getFromApi = async ({
   trustedOrigin
 }) => {
   try {
-    const requestFetch = fetch != null ? fetch : getOriginalFetch();
+    const requestFetch = fetch ?? getOriginalFetch2();
     const outgoingHeaders = credentialedOrigin !== void 0 && !isSameOrigin(url, credentialedOrigin) ? {} : headers;
     const requestHeaders = withUserAgentSuffix(
       outgoingHeaders,
-      `ai-sdk/provider-utils/${VERSION}`,
+      `ai-sdk-provider-utils/${VERSION}`,
       getRuntimeEnvironmentUserAgent()
     );
     const response = validateUrl ? await fetchWithValidatedRedirects({
@@ -1373,10 +1570,10 @@ var getFromApi = async ({
           requestBodyValues: {}
         });
       } catch (error) {
-        if (isAbortError(error) || APICallError2.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
-        throw new APICallError2({
+        throw new APICallError3({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -1395,11 +1592,11 @@ var getFromApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || APICallError2.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
       }
-      throw new APICallError2({
+      throw new APICallError3({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -1438,8 +1635,7 @@ function injectJsonInstructionIntoMessages({
   schemaPrefix,
   schemaSuffix
 }) {
-  var _a3, _b3;
-  const systemMessage = ((_a3 = messages[0]) == null ? void 0 : _a3.role) === "system" ? { ...messages[0] } : { role: "system", content: "" };
+  const systemMessage = messages[0]?.role === "system" ? { ...messages[0] } : { role: "system", content: "" };
   systemMessage.content = injectJsonInstruction({
     prompt: systemMessage.content,
     schema,
@@ -1448,14 +1644,13 @@ function injectJsonInstructionIntoMessages({
   });
   return [
     systemMessage,
-    ...((_b3 = messages[0]) == null ? void 0 : _b3.role) === "system" ? messages.slice(1) : messages
+    ...messages[0]?.role === "system" ? messages.slice(1) : messages
   ];
 }
 
 // src/is-buffer.ts
 function isBuffer(value) {
-  var _a3, _b3;
-  return (_b3 = (_a3 = globalThis.Buffer) == null ? void 0 : _a3.isBuffer(value)) != null ? _b3 : false;
+  return globalThis.Buffer?.isBuffer(value) ?? false;
 }
 
 // src/is-non-nullable.ts
@@ -1492,7 +1687,7 @@ function isUrlSupported({
     if (isTopLevelOnly) {
       return `${mediaType}/` === mediaTypePrefix;
     }
-    return mediaType.startsWith(mediaTypePrefix);
+    return mediaTypePrefix.endsWith("/") ? mediaType.startsWith(mediaTypePrefix) : mediaType === mediaTypePrefix;
   }).flatMap(({ regexes }) => regexes).some((pattern) => testRegExpFromStart(pattern, url));
 }
 function testRegExpFromStart(pattern, value) {
@@ -1655,15 +1850,34 @@ function mapReasoningToProviderBudget({
 
 // src/media-type-to-extension.ts
 function mediaTypeToExtension(mediaType) {
-  var _a3;
   const [_type, subtype = ""] = mediaType.toLowerCase().split("/");
-  return (_a3 = {
+  return {
     mpeg: "mp3",
     "x-wav": "wav",
     opus: "ogg",
     mp4: "m4a",
     "x-m4a": "m4a"
-  }[subtype]) != null ? _a3 : subtype;
+  }[subtype] ?? subtype;
+}
+
+// src/normalize-batch-request-counts.ts
+function normalizeBatchRequestCounts({
+  total,
+  pending,
+  completed,
+  failed
+}) {
+  if (isNonNegativeSafeInteger(total) && isNonNegativeSafeInteger(pending) && isNonNegativeSafeInteger(completed) && isNonNegativeSafeInteger(failed) && pending + completed + failed === total) {
+    return {
+      total,
+      pending,
+      completed,
+      failed
+    };
+  }
+}
+function isNonNegativeSafeInteger(value) {
+  return value != null && Number.isSafeInteger(value) && value >= 0;
 }
 
 // src/parse-json.ts
@@ -1711,7 +1925,7 @@ function secureJsonParse(text) {
   const { stackTraceLimit } = Error;
   try {
     Error.stackTraceLimit = 0;
-  } catch (e) {
+  } catch {
     return _parse(text);
   }
   try {
@@ -1734,7 +1948,8 @@ import { toJSONSchema } from "zod/v4/core";
 // src/add-additional-properties-to-json-schema.ts
 function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
   if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
-    jsonSchema2.additionalProperties = false;
+    const { additionalProperties } = jsonSchema2;
+    jsonSchema2.additionalProperties = additionalProperties != null && typeof additionalProperties !== "boolean" ? visit(additionalProperties) : false;
     const { properties } = jsonSchema2;
     if (properties != null) {
       for (const key of Object.keys(properties)) {
@@ -1807,11 +2022,10 @@ function parseAnyDef() {
 
 // src/to-json-schema/zod3-to-json-schema/parsers/array.ts
 function parseArrayDef(def, refs) {
-  var _a3, _b3, _c;
   const res = {
     type: "array"
   };
-  if (((_a3 = def.type) == null ? void 0 : _a3._def) && ((_c = (_b3 = def.type) == null ? void 0 : _b3._def) == null ? void 0 : _c.typeName) !== "ZodAny") {
+  if (def.type?._def && def.type?._def?.typeName !== "ZodAny") {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -1878,7 +2092,7 @@ var parseCatchDef = (def, refs) => {
 
 // src/to-json-schema/zod3-to-json-schema/parsers/date.ts
 function parseDateDef(def, refs, overrideDateStrategy) {
-  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
       anyOf: strategy.map((item) => parseDateDef(def, refs, item))
@@ -1997,7 +2211,7 @@ var zodPatterns = {
   /**
    * `a-z` was added to replicate /i flag
    */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9-]*\.)+[a-zA-Z]{2,}$/,
   /**
    * Constructed a valid Unicode RegExp
    *
@@ -2199,8 +2413,7 @@ function escapeNonAlphaNumeric(source) {
   return result;
 }
 function addFormat(schema, value, message, refs) {
-  var _a3;
-  if (schema.format || ((_a3 = schema.anyOf) == null ? void 0 : _a3.some((x) => x.format))) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
     if (!schema.anyOf) {
       schema.anyOf = [];
     }
@@ -2219,8 +2432,7 @@ function addFormat(schema, value, message, refs) {
   }
 }
 function addPattern(schema, regex, message, refs) {
-  var _a3;
-  if (schema.pattern || ((_a3 = schema.allOf) == null ? void 0 : _a3.some((x) => x.pattern))) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
     if (!schema.allOf) {
       schema.allOf = [];
     }
@@ -2239,7 +2451,6 @@ function addPattern(schema, regex, message, refs) {
   }
 }
 function stringifyRegExpWithFlags(regex, refs) {
-  var _a3;
   if (!refs.applyRegexFlags || !regex.flags) {
     return regex.source;
   }
@@ -2269,7 +2480,7 @@ function stringifyRegExpWithFlags(regex, refs) {
             pattern += source[i];
             pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
             inCharRange = false;
-          } else if (source[i + 1] === "-" && ((_a3 = source[i + 2]) == null ? void 0 : _a3.match(/[a-z]/))) {
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
             pattern += source[i];
             inCharRange = true;
           } else {
@@ -2310,7 +2521,7 @@ function stringifyRegExpWithFlags(regex, refs) {
   }
   try {
     new RegExp(pattern);
-  } catch (e) {
+  } catch {
     console.warn(
       `Could not convert regex pattern at ${refs.currentPath.join(
         "/"
@@ -2323,28 +2534,27 @@ function stringifyRegExpWithFlags(regex, refs) {
 
 // src/to-json-schema/zod3-to-json-schema/parsers/record.ts
 function parseRecordDef(def, refs) {
-  var _a3, _b3, _c, _d, _e, _f;
   const schema = {
     type: "object",
-    additionalProperties: (_a3 = parseDef(def.valueType._def, {
+    additionalProperties: parseDef(def.valueType._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
-    })) != null ? _a3 : refs.allowedAdditionalProperties
+    }) ?? refs.allowedAdditionalProperties
   };
-  if (((_b3 = def.keyType) == null ? void 0 : _b3._def.typeName) === "ZodString" && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+  if (def.keyType?._def.typeName === "ZodString" && def.keyType._def.checks?.length) {
     const { type: _type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === "ZodEnum") {
+  } else if (def.keyType?._def.typeName === "ZodEnum") {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === "ZodBranded" && def.keyType._def.type._def.typeName === "ZodString" && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+  } else if (def.keyType?._def.typeName === "ZodBranded" && def.keyType._def.type._def.typeName === "ZodString" && def.keyType._def.type._def.checks?.length) {
     const { type: _type, ...keyType } = parseBrandedDef(
       def.keyType._def,
       refs
@@ -2597,15 +2807,14 @@ function decideAdditionalProperties(def, refs) {
 function safeIsOptional(schema) {
   try {
     return schema.isOptional();
-  } catch (e) {
+  } catch {
     return true;
   }
 }
 
 // src/to-json-schema/zod3-to-json-schema/parsers/optional.ts
 var parseOptionalDef = (def, refs) => {
-  var _a3;
-  if (refs.currentPath.toString() === ((_a3 = refs.propertyPath) == null ? void 0 : _a3.toString())) {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
     return parseDef(def.innerType._def, refs);
   }
   const innerSchema = parseDef(def.innerType._def, {
@@ -2804,11 +3013,9 @@ var getRelativePath = (pathA, pathB) => {
 
 // src/to-json-schema/zod3-to-json-schema/parse-def.ts
 function parseDef(def, refs, forceResolution = false) {
-  var _a3;
   const seenItem = refs.seen.get(def);
   if (refs.override) {
-    const overrideResult = (_a3 = refs.override) == null ? void 0 : _a3.call(
-      refs,
+    const overrideResult = refs.override?.(
       def,
       refs,
       seenItem,
@@ -2890,34 +3097,30 @@ var getRefs = (options) => {
 
 // src/to-json-schema/zod3-to-json-schema/zod3-to-json-schema.ts
 var zod3ToJsonSchema = (schema, options) => {
-  var _a3;
   const refs = getRefs(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
-    (acc, [name4, schema2]) => {
-      var _a4;
-      return {
-        ...acc,
-        [name4]: (_a4 = parseDef(
-          schema2._def,
-          {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name4]
-          },
-          true
-        )) != null ? _a4 : parseAnyDef()
-      };
-    },
+    (acc, [name4, schema2]) => ({
+      ...acc,
+      [name4]: parseDef(
+        schema2._def,
+        {
+          ...refs,
+          currentPath: [...refs.basePath, refs.definitionPath, name4]
+        },
+        true
+      ) ?? parseAnyDef()
+    }),
     {}
   ) : void 0;
-  const name3 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = (_a3 = parseDef(
+  const name3 = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+  const main = parseDef(
     schema._def,
     name3 === void 0 ? refs : {
       ...refs,
       currentPath: [...refs.basePath, refs.definitionPath, name3]
     },
     false
-  )) != null ? _a3 : parseAnyDef();
+  ) ?? parseAnyDef();
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
     main.title = title;
@@ -3009,8 +3212,7 @@ function hasStandardJsonSchema(schema) {
   return schema["~standard"].jsonSchema != null;
 }
 function zod3Schema(zodSchema2, options) {
-  var _a3;
-  const useReferences = (_a3 = options == null ? void 0 : options.useReferences) != null ? _a3 : false;
+  const useReferences = options?.useReferences ?? false;
   return jsonSchema(
     // defer json schema creation to avoid unnecessary computation when only validation is needed
     () => zod3ToJsonSchema(zodSchema2, {
@@ -3025,8 +3227,7 @@ function zod3Schema(zodSchema2, options) {
   );
 }
 function zod4Schema(zodSchema2, options) {
-  var _a3;
-  const useReferences = (_a3 = options == null ? void 0 : options.useReferences) != null ? _a3 : false;
+  const useReferences = options?.useReferences ?? false;
   return jsonSchema(
     // defer json schema creation to avoid unnecessary computation when only validation is needed
     () => addAdditionalPropertiesToJsonSchema(
@@ -3135,7 +3336,7 @@ function isParsableJson(input) {
   try {
     secureJsonParse(input);
     return true;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
@@ -3167,7 +3368,7 @@ async function parseProviderOptions({
   providerOptions,
   schema
 }) {
-  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
+  if (providerOptions?.[provider] == null) {
     return void 0;
   }
   const parsedProviderOptions = await safeValidateTypes({
@@ -3184,9 +3385,179 @@ async function parseProviderOptions({
   return parsedProviderOptions.value;
 }
 
+// src/post-multipart-stream-to-api.ts
+import { APICallError as APICallError4 } from "@ai-sdk/provider";
+var getOriginalFetch3 = () => globalThis.fetch;
+function escapeMultipartHeaderValue(value) {
+  return value.replace(/[\r\n]/g, "").replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function createMultipartBody(parts, boundary) {
+  const encoder = new TextEncoder();
+  let disposed = false;
+  let activeReader;
+  const enteredStreams = /* @__PURE__ */ new Set();
+  async function* emitParts() {
+    for (const part of parts) {
+      if (disposed) return;
+      const disposition = `--${boundary}\r
+Content-Disposition: form-data; name="${escapeMultipartHeaderValue(part.name)}"`;
+      if (part.type === "field") {
+        yield encoder.encode(`${disposition}\r
+\r
+${part.value}\r
+`);
+        continue;
+      }
+      const filenameParameter = `; filename="${escapeMultipartHeaderValue(
+        part.filename ?? "blob"
+      )}"`;
+      const mediaType = (part.mediaType ?? "application/octet-stream").replace(
+        /[\r\n]/g,
+        ""
+      );
+      yield encoder.encode(
+        `${disposition}${filenameParameter}\r
+Content-Type: ${mediaType}\r
+\r
+`
+      );
+      if (part.content instanceof Uint8Array) {
+        yield part.content;
+      } else {
+        const reader = part.content.getReader();
+        activeReader = reader;
+        enteredStreams.add(part.content);
+        let finished = false;
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done || disposed) {
+              finished = done;
+              break;
+            }
+            yield value;
+          }
+        } finally {
+          activeReader = void 0;
+          if (!finished) {
+            await reader.cancel().catch(() => {
+            });
+          }
+          reader.releaseLock();
+        }
+        if (disposed) return;
+      }
+      yield encoder.encode("\r\n");
+    }
+    yield encoder.encode(`--${boundary}--\r
+`);
+  }
+  return {
+    stream: convertAsyncIteratorToReadableStream(emitParts()),
+    async dispose(reason) {
+      if (disposed) return;
+      disposed = true;
+      const reader = activeReader;
+      if (reader != null) {
+        await reader.cancel(reason).catch(() => {
+        });
+      }
+      for (const part of parts) {
+        if (part.type === "file" && !(part.content instanceof Uint8Array) && !enteredStreams.has(part.content)) {
+          await part.content.cancel(reason).catch(() => {
+          });
+        }
+      }
+    }
+  };
+}
+var postMultipartStreamToApi = async ({
+  url,
+  headers = {},
+  parts,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch = getOriginalFetch3()
+}) => {
+  const boundary = `ai-sdk-multipart-${generateId()}`;
+  const requestBodyValues = Object.fromEntries(
+    parts.map((part) => [
+      part.name,
+      part.type === "field" ? part.value : `<file:${part.filename ?? part.name}>`
+    ])
+  );
+  const body = createMultipartBody(parts, boundary);
+  try {
+    const requestInit = {
+      method: "POST",
+      headers: withUserAgentSuffix(
+        {
+          ...headers,
+          "Content-Type": `multipart/form-data; boundary=${boundary}`
+        },
+        `ai-sdk-provider-utils/${VERSION}`,
+        getRuntimeEnvironmentUserAgent()
+      ),
+      body: body.stream,
+      duplex: "half",
+      signal: abortSignal
+    };
+    const response = await fetch(url, requestInit);
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url,
+          requestBodyValues
+        });
+      } catch (error) {
+        if (isAbortError(error) || APICallError4.isInstance(error)) {
+          throw error;
+        }
+        throw new APICallError4({
+          message: "Failed to process error response",
+          cause: error,
+          statusCode: response.status,
+          url,
+          responseHeaders,
+          requestBodyValues
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url,
+        requestBodyValues
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isAbortError(error) || APICallError4.isInstance(error)) {
+          throw error;
+        }
+      }
+      throw new APICallError4({
+        message: "Failed to process successful response",
+        cause: error,
+        statusCode: response.status,
+        url,
+        responseHeaders,
+        requestBodyValues
+      });
+    }
+  } catch (error) {
+    await body.dispose(error);
+    throw handleFetchError({ error, url, requestBodyValues });
+  }
+};
+
 // src/post-to-api.ts
-import { APICallError as APICallError3 } from "@ai-sdk/provider";
-var getOriginalFetch2 = () => globalThis.fetch;
+import { APICallError as APICallError5 } from "@ai-sdk/provider";
+var getOriginalFetch4 = () => globalThis.fetch;
 var postJsonToApi = async ({
   url,
   headers,
@@ -3237,14 +3608,14 @@ var postToApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch = getOriginalFetch2()
+  fetch = getOriginalFetch4()
 }) => {
   try {
     const response = await fetch(url, {
       method: "POST",
       headers: withUserAgentSuffix(
         headers,
-        `ai-sdk/provider-utils/${VERSION}`,
+        `ai-sdk-provider-utils/${VERSION}`,
         getRuntimeEnvironmentUserAgent()
       ),
       body: body.content,
@@ -3260,10 +3631,10 @@ var postToApi = async ({
           requestBodyValues: body.values
         });
       } catch (error) {
-        if (isAbortError(error) || APICallError3.isInstance(error)) {
+        if (isAbortError(error) || APICallError5.isInstance(error)) {
           throw error;
         }
-        throw new APICallError3({
+        throw new APICallError5({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -3282,11 +3653,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || APICallError3.isInstance(error)) {
+        if (isAbortError(error) || APICallError5.isInstance(error)) {
           throw error;
         }
       }
-      throw new APICallError3({
+      throw new APICallError5({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -3397,12 +3768,12 @@ async function resolve(value) {
   if (typeof value === "function") {
     value = value();
   }
-  return Promise.resolve(value);
+  return value;
 }
 
 // src/resolve-full-media-type.ts
 import {
-  UnsupportedFunctionalityError
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 function resolveFullMediaType({
   part
@@ -3418,11 +3789,11 @@ function resolveFullMediaType({
     if (detected) {
       return detected;
     }
-    throw new UnsupportedFunctionalityError({
+    throw new UnsupportedFunctionalityError2({
       functionality: `file of media type "${part.mediaType}" must specify subtype since it could not be auto-detected`
     });
   }
-  throw new UnsupportedFunctionalityError({
+  throw new UnsupportedFunctionalityError2({
     functionality: `file of media type "${part.mediaType}" must specify subtype since it is not passed as inline bytes`
   });
 }
@@ -3525,8 +3896,64 @@ async function retryWithExponentialBackoffInternal(f, {
 }
 
 // src/response-handler.ts
-import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
+import { APICallError as APICallError6, EmptyResponseBodyError } from "@ai-sdk/provider";
 var textDecoder2 = new TextDecoder();
+function wrapResponseBodyStream({
+  stream,
+  url,
+  requestBodyValues,
+  statusCode,
+  responseHeaders
+}) {
+  const reader = stream.getReader();
+  let readerReleased = false;
+  const releaseReader = () => {
+    if (!readerReleased) {
+      reader.releaseLock();
+      readerReleased = true;
+    }
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          releaseReader();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        releaseReader();
+        if (isAbortError(error)) {
+          controller.error(error);
+          return;
+        }
+        controller.error(
+          handleFetchError({
+            error: new APICallError6({
+              message: "Failed to process successful response",
+              cause: error,
+              statusCode,
+              url,
+              responseHeaders,
+              requestBodyValues
+            }),
+            url,
+            requestBodyValues
+          })
+        );
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        releaseReader();
+      }
+    }
+  });
+}
 async function readResponseBodyAsText({
   response,
   url
@@ -3548,14 +3975,14 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new APICallError4({
+      value: new APICallError6({
         message: response.statusText,
         url,
         requestBodyValues,
         statusCode: response.status,
         responseHeaders,
         responseBody,
-        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+        isRetryable: isRetryable?.(response)
       })
     };
   }
@@ -3566,7 +3993,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new APICallError4({
+      value: new APICallError6({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -3574,25 +4001,25 @@ var createJsonErrorResponseHandler = ({
         responseHeaders,
         responseBody,
         data: parsedError,
-        isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
+        isRetryable: isRetryable?.(response, parsedError)
       })
     };
-  } catch (e) {
+  } catch {
     return {
       responseHeaders,
-      value: new APICallError4({
+      value: new APICallError6({
         message: response.statusText,
         url,
         requestBodyValues,
         statusCode: response.status,
         responseHeaders,
         responseBody,
-        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+        isRetryable: isRetryable?.(response)
       })
     };
   }
 };
-var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
     throw new EmptyResponseBodyError({});
@@ -3600,7 +4027,13 @@ var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) =>
   return {
     responseHeaders,
     value: parseJsonEventStream({
-      stream: response.body,
+      stream: wrapResponseBodyStream({
+        stream: response.body,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders
+      }),
       schema: chunkSchema
     })
   };
@@ -3613,7 +4046,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new APICallError4({
+    throw new APICallError6({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -3629,10 +4062,62 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     rawValue: parsedResult.rawValue
   };
 };
+var createJsonLinesResponseHandler = (responseSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  return {
+    responseHeaders,
+    value: parseJsonLines({
+      stream: response.body,
+      schema: responseSchema
+    })
+  };
+};
+async function* parseJsonLines({
+  stream,
+  schema
+}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let finished = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        finished = true;
+        buffer += decoder.decode();
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let lineEnd = buffer.indexOf("\n");
+      while (lineEnd !== -1) {
+        const line = buffer.slice(0, lineEnd).replace(/\r$/, "");
+        buffer = buffer.slice(lineEnd + 1);
+        if (line.trim().length > 0) {
+          yield await parseJSON({ text: line, schema });
+        }
+        lineEnd = buffer.indexOf("\n");
+      }
+    }
+    const finalLine = buffer.replace(/\r$/, "");
+    if (finalLine.trim().length > 0) {
+      yield await parseJSON({ text: finalLine, schema });
+    }
+  } finally {
+    if (!finished) {
+      await reader.cancel().catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
 var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (!response.body) {
-    throw new APICallError4({
+    throw new APICallError6({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -3648,7 +4133,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
       value: new Uint8Array(buffer)
     };
   } catch (error) {
-    throw new APICallError4({
+    throw new APICallError6({
       message: "Failed to read response as array buffer",
       url,
       requestBodyValues,
@@ -3659,12 +4144,28 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
     });
   }
 };
+var createBinaryStreamResponseHandler = () => async ({ response, url, requestBodyValues }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  return {
+    responseHeaders,
+    value: wrapResponseBodyStream({
+      stream: response.body,
+      url,
+      requestBodyValues,
+      statusCode: response.status,
+      responseHeaders
+    })
+  };
+};
 var createStatusCodeErrorResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   const responseBody = await readResponseBodyAsText({ response, url });
   return {
     responseHeaders,
-    value: new APICallError4({
+    value: new APICallError6({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -3696,8 +4197,8 @@ function isJSONSerializable(value) {
 // src/serialization-error.ts
 import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
 var name2 = "AI_SerializationError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker3);
 var _a2, _b2;
 var SerializationError = class extends (_b2 = AISDKError2, _a2 = symbol2, _b2) {
   // used in isInstance
@@ -3709,7 +4210,7 @@ var SerializationError = class extends (_b2 = AISDKError2, _a2 = symbol2, _b2) {
     this[_a2] = true;
   }
   static isInstance(error) {
-    return AISDKError2.hasMarker(error, marker2);
+    return AISDKError2.hasMarker(error, marker3);
   }
 };
 
@@ -3745,16 +4246,87 @@ function resolveSync(value) {
 import {
   InvalidResponseDataError
 } from "@ai-sdk/provider";
-function absentIfBlank(value) {
-  return value != null && value.trim() !== "" ? value : void 0;
+
+// src/streaming-tool-call-argument-state.ts
+function startsWithStructuredValue(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const firstCharacter = value.trimStart()[0];
+  return firstCharacter === "{" || firstCharacter === "[";
 }
+var StreamingToolCallArgumentState = class {
+  constructor(initialValue = "") {
+    this.structure = { kind: "undetermined" };
+    this.append(initialValue);
+  }
+  get hasCompleteStructuredValue() {
+    return this.structure.kind === "structured" && this.structure.complete === true;
+  }
+  append(delta) {
+    let nextStructure = this.structure;
+    for (const character of delta) {
+      if (nextStructure.kind === "undetermined") {
+        if (/\s/.test(character)) {
+          continue;
+        }
+        if (character !== "{" && character !== "[") {
+          nextStructure = { kind: "other" };
+          continue;
+        }
+        nextStructure = {
+          kind: "structured",
+          stack: [character],
+          inString: false,
+          escaped: false,
+          complete: false
+        };
+        continue;
+      }
+      if (nextStructure.kind !== "structured" || nextStructure.complete) {
+        continue;
+      }
+      if (nextStructure.inString) {
+        if (nextStructure.escaped) {
+          nextStructure.escaped = false;
+        } else if (character === "\\") {
+          nextStructure.escaped = true;
+        } else if (character === '"') {
+          nextStructure.inString = false;
+        }
+        continue;
+      }
+      if (character === '"') {
+        nextStructure.inString = true;
+      } else if (character === "{" || character === "[") {
+        nextStructure.stack.push(character);
+      } else if (character === "}" || character === "]") {
+        const expectedOpening = character === "}" ? "{" : "[";
+        if (nextStructure.stack.at(-1) !== expectedOpening) {
+          nextStructure = { kind: "other" };
+          continue;
+        }
+        nextStructure.stack.pop();
+        if (nextStructure.stack.length === 0) {
+          nextStructure.complete = true;
+        }
+      }
+    }
+    this.structure = nextStructure;
+  }
+};
+
+// src/streaming-tool-call-tracker.ts
 var StreamingToolCallTracker = class {
   constructor(controller, options = {}) {
     this.toolCalls = [];
-    var _a3, _b3;
+    this.toolCallsById = /* @__PURE__ */ new Map();
+    this.toolCallsByIndex = /* @__PURE__ */ new Map();
+    this.usedToolCallIds = /* @__PURE__ */ new Set();
+    this.nextGeneratedIdSuffixes = /* @__PURE__ */ new Map();
     this.controller = controller;
-    this._generateId = (_a3 = options.generateId) != null ? _a3 : generateId;
-    this.typeValidation = (_b3 = options.typeValidation) != null ? _b3 : "none";
+    this._generateId = options.generateId ?? generateId;
+    this.typeValidation = options.typeValidation ?? "none";
     this.extractMetadata = options.extractMetadata;
     this.buildToolCallProviderMetadata = options.buildToolCallProviderMetadata;
   }
@@ -3764,90 +4336,161 @@ var StreamingToolCallTracker = class {
    * events as appropriate.
    */
   processDelta(toolCallDelta) {
-    var _a3;
-    const wireId = absentIfBlank(toolCallDelta.id);
-    const wireIndex = toolCallDelta.index != null ? toolCallDelta.index : void 0;
-    const wireName = absentIfBlank((_a3 = toolCallDelta.function) == null ? void 0 : _a3.name);
-    let toolCall = this.findByAlias(wireId, wireIndex, wireName);
-    if (toolCall == null && this.toolCalls.length === 1) {
-      const only = this.toolCalls[0];
-      if ((wireName === void 0 || only.function.name === wireName) && (wireId === void 0 || only.wireId === void 0) && (wireIndex === void 0 || only.index === void 0)) {
-        toolCall = only;
-      }
-    }
-    if (toolCall == null) {
-      this.processNewToolCall(toolCallDelta, wireId, wireIndex, wireName);
-      return;
+    const wireName = toolCallDelta.function?.name;
+    const wireId = this.getNonBlankString(toolCallDelta.id);
+    const name3 = this.getNonBlankString(wireName);
+    const { index } = toolCallDelta;
+    const resolution = this.resolveToolCall({
+      wireId,
+      index,
+      name: name3,
+      hasExplicitCallStart: name3 != null && startsWithStructuredValue(toolCallDelta.function?.arguments)
+    });
+    if (resolution.kind === "ambiguous") {
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: "Ambiguous streamed tool call delta."
+      });
     }
-    if (wireId !== void 0) {
-      toolCall.wireId = wireId;
+    let toolCall;
+    if (resolution.kind === "new") {
+      toolCall = this.processNewToolCall(toolCallDelta, {
+        wireId,
+        index,
+        name: name3
+      });
+    } else {
+      toolCall = resolution.toolCall;
+      if (wireId != null) {
+        this.associateWireId(toolCall, wireId);
+      }
+      this.processExistingToolCall(toolCall, toolCallDelta);
     }
-    if (wireIndex !== void 0) {
-      toolCall.index = wireIndex;
+    if (index != null) {
+      this.associateIndex(toolCall, index);
     }
-    this.processExistingToolCall(toolCall, toolCallDelta);
   }
   /**
-   * The most recent tool call this delta's aliases claim. An alias the candidate has not
-   * seen yet cannot disagree, so it neither matches nor rejects; at least one alias must
-   * actually match, which is why a delta carrying only arguments never resolves here.
-   *
-   * Scanning stops at the first call an alias claims, and a `function.name` that disagrees
-   * with that call rejects the delta rather than letting the scan continue. Continuing past
-   * it reaches a call whose claim on the alias a later call has already superseded, which
-   * files a whole new call as a continuation of one two positions back.
+   * Finalize any unfinished tool calls. Should be called during the stream's
+   * flush handler to ensure all tool calls are properly completed.
    */
+  flush() {
+    const toolCalls = this.toolCalls.every((toolCall) => toolCall.index != null) ? [...this.toolCalls].sort(
+      (a, b) => a.index - b.index || a.sequence - b.sequence
+    ) : this.toolCalls;
+    for (const toolCall of toolCalls) {
+      if (!toolCall.hasFinished) {
+        this.finishToolCall(toolCall);
+      }
+    }
+  }
   /**
-   * Whether an alias the delta carries, but the matched call has not claimed, belongs to some
-   * other call. The delta then addresses two calls at once, which resolves to neither — the
-   * other claimant cannot be it either, because the alias it did match rejected that call
-   * already. Agreement has to be read across the record set: a candidate missing the alias is
-   * not contradicted by it on its own, and reading only the candidate let exactly this
-   * contradiction resolve, silently, onto a call the gateway never addressed.
+   * Correlation precedence for streamed deltas:
+   *
+   * | ID evidence | index/name evidence | start evidence | resolution |
+   * | --- | --- | --- | --- |
+   * | known | matching | any | matching call, new call, or ambiguity |
+   * | known | conflicting | named | new call |
+   * | unseen | matching | structured start | new call |
+   * | unseen | matching | continuation | matching call or ambiguity |
+   * | absent | matching | any | matching call, new call, or ambiguity |
+   * | absent | absent | named | new call |
+   * | absent | absent | unnamed | sole unfinished call, new call, or ambiguity |
    */
-  claimedByAnother(candidate, alias, value) {
-    return value !== void 0 && candidate[alias] === void 0 && this.toolCalls.some((other) => other !== candidate && other[alias] === value);
-  }
-  findByAlias(wireId, wireIndex, wireName) {
-    for (let position = this.toolCalls.length - 1; position >= 0; position--) {
-      const candidate = this.toolCalls[position];
-      let matched = false;
-      if (wireIndex !== void 0 && candidate.index !== void 0) {
-        if (candidate.index !== wireIndex) {
-          continue;
+  resolveToolCall({
+    wireId,
+    index,
+    name: name3,
+    hasExplicitCallStart
+  }) {
+    const indexedToolCalls = index != null ? this.toolCallsByIndex.get(index) : void 0;
+    const matchingIndexedToolCalls = this.filterToolCallsByName(
+      indexedToolCalls,
+      name3
+    );
+    if (wireId != null) {
+      const toolCallsWithId = this.toolCallsById.get(wireId);
+      if (toolCallsWithId != null) {
+        if (index != null) {
+          const matchingToolCalls = matchingIndexedToolCalls.filter(
+            (toolCall) => toolCallsWithId.has(toolCall)
+          );
+          const matchingToolCall = this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart
+          );
+          if (matchingToolCall.kind !== "new") {
+            return matchingToolCall;
+          }
+          if (name3 != null) {
+            return { kind: "new" };
+          }
+          if (indexedToolCalls != null) {
+            return { kind: "ambiguous" };
+          }
+          return this.resolveMatchingToolCall([...toolCallsWithId], false);
         }
-        matched = true;
-      }
-      if (wireId !== void 0 && candidate.wireId !== void 0) {
-        if (candidate.wireId !== wireId) {
-          continue;
+        if (name3 != null) {
+          const matchingToolCalls = [...toolCallsWithId].filter(
+            (toolCall) => toolCall.function.name === name3
+          );
+          return this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart
+          );
         }
-        matched = true;
+        return this.resolveMatchingToolCall([...toolCallsWithId], false);
       }
-      if (matched) {
-        if (this.claimedByAnother(candidate, "wireId", wireId) || this.claimedByAnother(candidate, "index", wireIndex)) {
-          return void 0;
-        }
-        return wireName !== void 0 && candidate.function.name !== wireName ? void 0 : candidate;
+      if (matchingIndexedToolCalls.length > 0) {
+        return hasExplicitCallStart ? { kind: "new" } : this.resolveMatchingToolCall(matchingIndexedToolCalls, false);
       }
+      return { kind: "new" };
     }
-    return void 0;
+    if (indexedToolCalls != null) {
+      return this.resolveMatchingToolCall(
+        matchingIndexedToolCalls,
+        hasExplicitCallStart
+      );
+    }
+    if (name3 != null) {
+      return { kind: "new" };
+    }
+    const unfinishedToolCalls = this.toolCalls.filter(
+      (toolCall) => !toolCall.hasFinished
+    );
+    if (unfinishedToolCalls.length === 1) {
+      return { kind: "existing", toolCall: unfinishedToolCalls[0] };
+    }
+    return unfinishedToolCalls.length > 1 ? { kind: "ambiguous" } : { kind: "new" };
   }
-  /**
-   * Finalize any unfinished tool calls. Should be called during the stream's
-   * flush handler to ensure all tool calls are properly completed.
-   */
-  flush() {
-    const indices = this.toolCalls.map((toolCall) => toolCall.index);
-    const ordered = indices.every((index) => index !== void 0) && new Set(indices).size === indices.length ? [...this.toolCalls].sort((a, b) => a.index - b.index) : this.toolCalls;
-    for (const toolCall of ordered) {
-      if (!toolCall.hasFinished) {
-        this.finishToolCall(toolCall);
-      }
+  filterToolCallsByName(toolCalls, name3) {
+    if (toolCalls == null) {
+      return [];
     }
+    return [...toolCalls].filter(
+      (toolCall) => name3 == null || toolCall.function.name === name3
+    );
   }
-  processNewToolCall(toolCallDelta, wireId, wireIndex, wireName) {
-    var _a3, _b3;
+  resolveMatchingToolCall(toolCalls, hasExplicitCallStart) {
+    if (toolCalls.length === 0) {
+      return { kind: "new" };
+    }
+    if (!hasExplicitCallStart) {
+      return toolCalls.length === 1 ? { kind: "existing", toolCall: toolCalls[0] } : { kind: "ambiguous" };
+    }
+    const continuableToolCalls = toolCalls.filter(
+      (toolCall) => !toolCall.argumentState.hasCompleteStructuredValue
+    );
+    if (continuableToolCalls.length === 1) {
+      return { kind: "existing", toolCall: continuableToolCalls[0] };
+    }
+    return continuableToolCalls.length > 1 ? { kind: "ambiguous" } : { kind: "new" };
+  }
+  processNewToolCall(toolCallDelta, {
+    wireId,
+    index,
+    name: name3
+  }) {
     if (this.typeValidation === "required") {
       if (toolCallDelta.type !== "function") {
         throw new InvalidResponseDataError({
@@ -3863,32 +4506,37 @@ var StreamingToolCallTracker = class {
         });
       }
     }
-    if (wireName === void 0) {
+    if (name3 == null) {
       throw new InvalidResponseDataError({
         data: toolCallDelta,
         message: `Expected 'function.name' to be a string.`
       });
     }
-    const mintedId = wireId === void 0 || this.toolCalls.some((candidate) => candidate.id === wireId) ? this._generateId() : wireId;
+    const id = this.createToolCallId(wireId);
     this.controller.enqueue({
       type: "tool-input-start",
-      id: mintedId,
-      toolName: wireName
+      id,
+      toolName: name3
     });
-    const metadata = (_a3 = this.extractMetadata) == null ? void 0 : _a3.call(this, toolCallDelta);
+    const metadata = this.extractMetadata?.(toolCallDelta);
+    const initialArguments = toolCallDelta.function?.arguments ?? "";
     const toolCall = {
-      id: mintedId,
+      id,
+      index: index ?? void 0,
+      sequence: this.toolCalls.length,
       type: "function",
       function: {
-        name: wireName,
-        arguments: (_b3 = toolCallDelta.function.arguments) != null ? _b3 : ""
+        name: name3,
+        arguments: initialArguments
       },
+      argumentState: new StreamingToolCallArgumentState(initialArguments),
       hasFinished: false,
-      metadata,
-      wireId,
-      index: wireIndex
+      metadata
     };
     this.toolCalls.push(toolCall);
+    if (wireId != null) {
+      this.associateWireId(toolCall, wireId);
+    }
     if (toolCall.function.arguments.length > 0) {
       this.controller.enqueue({
         type: "tool-input-delta",
@@ -3898,12 +4546,53 @@ var StreamingToolCallTracker = class {
     }
     return toolCall;
   }
+  associateWireId(toolCall, wireId) {
+    let toolCallsWithId = this.toolCallsById.get(wireId);
+    if (toolCallsWithId == null) {
+      toolCallsWithId = /* @__PURE__ */ new Set();
+      this.toolCallsById.set(wireId, toolCallsWithId);
+    }
+    toolCallsWithId.add(toolCall);
+  }
+  associateIndex(toolCall, index) {
+    let toolCallsWithIndex = this.toolCallsByIndex.get(index);
+    if (toolCallsWithIndex == null) {
+      toolCallsWithIndex = /* @__PURE__ */ new Set();
+      this.toolCallsByIndex.set(index, toolCallsWithIndex);
+    }
+    toolCallsWithIndex.add(toolCall);
+  }
+  createToolCallId(wireId) {
+    if (wireId != null && !this.usedToolCallIds.has(wireId)) {
+      this.usedToolCallIds.add(wireId);
+      return wireId;
+    }
+    const generatedId = this.getNonBlankString(this._generateId()) ?? "tool-call";
+    if (!this.usedToolCallIds.has(generatedId)) {
+      this.usedToolCallIds.add(generatedId);
+      return generatedId;
+    }
+    const initialSuffix = this.nextGeneratedIdSuffixes.get(generatedId) ?? 1;
+    const maximumSuffix = initialSuffix + this.usedToolCallIds.size;
+    for (let suffix = initialSuffix; suffix <= maximumSuffix; suffix++) {
+      const suffixedId = `${generatedId}-${suffix}`;
+      if (!this.usedToolCallIds.has(suffixedId)) {
+        this.usedToolCallIds.add(suffixedId);
+        this.nextGeneratedIdSuffixes.set(generatedId, suffix + 1);
+        return suffixedId;
+      }
+    }
+    throw new Error("Failed to create a unique tool call ID.");
+  }
+  getNonBlankString(value) {
+    return value != null && value.trim().length > 0 ? value : void 0;
+  }
   processExistingToolCall(toolCall, toolCallDelta) {
-    var _a3;
     if (toolCall.hasFinished) {
       return;
     }
-    if (((_a3 = toolCallDelta.function) == null ? void 0 : _a3.arguments) != null) {
+    if (toolCallDelta.function?.arguments != null) {
+      toolCall.argumentState.append(toolCallDelta.function.arguments);
       toolCall.function.arguments += toolCallDelta.function.arguments;
       this.controller.enqueue({
         type: "tool-input-delta",
@@ -3913,18 +4602,16 @@ var StreamingToolCallTracker = class {
     }
   }
   finishToolCall(toolCall) {
-    var _a3, _b3;
     this.controller.enqueue({
       type: "tool-input-end",
       id: toolCall.id
     });
-    const providerMetadata = (_a3 = this.buildToolCallProviderMetadata) == null ? void 0 : _a3.call(
-      this,
+    const providerMetadata = this.buildToolCallProviderMetadata?.(
       toolCall.metadata
     );
     this.controller.enqueue({
       type: "tool-call",
-      toolCallId: (_b3 = toolCall.id) != null ? _b3 : this._generateId(),
+      toolCallId: toolCall.id,
       toolName: toolCall.function.name,
       input: toolCall.function.arguments,
       ...providerMetadata ? { providerMetadata } : {}
@@ -3946,7 +4633,7 @@ function parseTranscriptionStreamClientFrame(text) {
   let value;
   try {
     value = secureJsonParse(text);
-  } catch (e) {
+  } catch {
     return { type: "invalid", message: "malformed JSON" };
   }
   if (value == null || typeof value !== "object" || Array.isArray(value)) {
@@ -4003,7 +4690,7 @@ function serializeTranscriptionStreamPart(part) {
       });
     }
     return JSON.stringify(part);
-  } catch (e) {
+  } catch {
     return void 0;
   }
 }
@@ -4014,7 +4701,7 @@ function parseTranscriptionStreamPart(text) {
   let value;
   try {
     value = secureJsonParse(text);
-  } catch (e) {
+  } catch {
     return void 0;
   }
   if (value == null || typeof value !== "object" || Array.isArray(value)) {
@@ -4073,7 +4760,7 @@ function isSegment(value) {
 // src/validate-base-url.ts
 import { InvalidArgumentError as InvalidArgumentError3 } from "@ai-sdk/provider";
 function validateBaseURL(baseURL) {
-  if ((baseURL == null ? void 0 : baseURL.trim()) === "") {
+  if (baseURL?.trim() === "") {
     throw new InvalidArgumentError3({
       argument: "baseURL",
       message: "baseURL must be a non-empty string."
@@ -4084,7 +4771,7 @@ function validateBaseURL(baseURL) {
 
 // src/without-trailing-slash.ts
 function withoutTrailingSlash(url) {
-  return url == null ? void 0 : url.replace(/\/$/, "");
+  return url?.replace(/\/$/, "");
 }
 
 // src/types/executable-tool.ts
@@ -4123,7 +4810,7 @@ function toolCaller(tool2, definition) {
   });
 }
 function getToolCaller(tool2) {
-  return tool2 == null ? void 0 : tool2.experimental_toolCaller;
+  return tool2?.experimental_toolCaller;
 }
 
 // src/index.ts
@@ -4135,6 +4822,8 @@ export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
+  EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
+  EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER as EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
   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,
@@ -4156,18 +4845,22 @@ export {
   convertToFormData,
   convertUint8ArrayToBase64,
   createBinaryResponseHandler,
+  createBinaryStreamResponseHandler,
   createEventSourceResponseHandler,
   createIdGenerator,
   createJsonErrorResponseHandler,
+  createJsonLinesResponseHandler,
   createJsonResponseHandler,
   createLanguageModelResponseMetadata,
   createNullLanguageModelUsage,
   createProviderDefinedToolFactory,
   createProviderDefinedToolFactoryWithOutputSchema,
   createProviderExecutedToolFactory,
+  createProviderStreamError,
   createStatusCodeErrorResponseHandler,
   createToolNameMapping,
   delay,
+  deleteFromApi,
   detectMediaType,
   downloadBlob,
   dynamicTool,
@@ -4179,6 +4872,8 @@ export {
   toolCaller as experimental_toolCaller,
   extractLines,
   extractResponseHeaders,
+  fetchUntrustedUrl,
+  fetchWithValidatedEndpoint,
   fetchWithValidatedRedirects,
   filterNullable,
   generateId,
@@ -4197,6 +4892,7 @@ export {
   isNonNullable,
   isParsableJson,
   isProviderReference,
+  isProviderStreamError,
   isRecord,
   isSameOrigin,
   isUrlSupported,
@@ -4208,12 +4904,14 @@ export {
   mapReasoningToProviderBudget,
   mapReasoningToProviderEffort,
   mediaTypeToExtension,
+  normalizeBatchRequestCounts,
   normalizeHeaders,
   parseJSON,
   parseJsonEventStream,
   parseProviderOptions,
   postFormDataToApi,
   postJsonToApi,
+  postMultipartStreamToApi,
   postToApi,
   readResponseWithSizeLimit,
   readWebSocketMessageText,