maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

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

@@ -204,6 +204,9 @@ function convertAsyncIteratorToReadableStream(iterator) {
   });
 }
 
+// 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 +215,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 +228,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);
   }
@@ -323,6 +335,31 @@ function createToolNameMapping({
   };
 }
 
+// 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
 var DelayedPromise = class {
   constructor() {
@@ -370,12 +407,234 @@ 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) {
+  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/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 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;
+  }
+  return void 0;
+}
+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.40" : "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 +668,7 @@ var imageMediaTypeSignatures = [
   },
   {
     mediaType: "image/bmp",
-    bytesPrefix: [66, 77]
+    bytesPrefix: [66, 77, null, null, null, null, 0, 0, 0, 0]
   },
   {
     mediaType: "image/tiff",
@@ -681,8 +940,8 @@ async function cancelResponseBody(response) {
 // 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 +958,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);
   }
 };
 
@@ -1012,6 +1271,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,
@@ -1020,6 +1300,7 @@ async function fetchWithValidatedRedirects({
   fetch: customFetch,
   trustedOrigin
 }) {
+  var _a3;
   let currentHeaders = headers === void 0 ? void 0 : sanitizeRequestHeaders(headers);
   const perHopInit = (redirect) => {
     const init = { signal: abortSignal, redirect };
@@ -1034,7 +1315,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,7 +1326,7 @@ async function fetchWithValidatedRedirects({
       }
       return await fetch(currentUrl, perHopInit("follow"));
     }
-    const location = response.headers.get("location");
+    const location = (_a3 = response.headers) == null ? void 0 : _a3.get("location");
     if (REDIRECT_STATUS_CODES.has(response.status) && location) {
       await cancelResponseBody(response);
       const nextUrl = new URL(location, currentUrl).toString();
@@ -1154,6 +1435,11 @@ 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"
+);
+
 // src/extract-lines.ts
 function extractLines({
   text,
@@ -1168,11 +1454,6 @@ function extractLines({
   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 +1492,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,7 +1506,7 @@ var getFromApi = async ({
   trustedOrigin
 }) => {
   try {
-    const requestFetch = fetch != null ? fetch : getOriginalFetch();
+    const requestFetch = fetch != null ? fetch : getOriginalFetch2();
     const outgoingHeaders = credentialedOrigin !== void 0 && !isSameOrigin(url, credentialedOrigin) ? {} : headers;
     const requestHeaders = withUserAgentSuffix(
       outgoingHeaders,
@@ -1373,10 +1534,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 +1556,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,
@@ -1666,6 +1827,27 @@ function mediaTypeToExtension(mediaType) {
   }[subtype]) != null ? _a3 : 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
+    };
+  }
+  return void 0;
+}
+function isNonNegativeSafeInteger(value) {
+  return value != null && Number.isSafeInteger(value) && value >= 0;
+}
+
 // src/parse-json.ts
 import {
   JSONParseError,
@@ -1734,7 +1916,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)) {
@@ -3184,9 +3367,183 @@ 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() {
+    var _a3, _b3;
+    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(
+        (_a3 = part.filename) != null ? _a3 : "blob"
+      )}"`;
+      const mediaType = ((_b3 = part.mediaType) != null ? _b3 : "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) => {
+      var _a3;
+      return [
+        part.name,
+        part.type === "field" ? part.value : `<file:${(_a3 = part.filename) != null ? _a3 : 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,7 +3594,7 @@ var postToApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch = getOriginalFetch2()
+  fetch = getOriginalFetch4()
 }) => {
   try {
     const response = await fetch(url, {
@@ -3260,10 +3617,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 +3639,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,
@@ -3402,7 +3759,7 @@ async function resolve(value) {
 
 // src/resolve-full-media-type.ts
 import {
-  UnsupportedFunctionalityError
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 function resolveFullMediaType({
   part
@@ -3418,11 +3775,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 +3882,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,7 +3961,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new APICallError4({
+      value: new APICallError6({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -3566,7 +3979,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new APICallError4({
+      value: new APICallError6({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -3580,7 +3993,7 @@ var createJsonErrorResponseHandler = ({
   } catch (e) {
     return {
       responseHeaders,
-      value: new APICallError4({
+      value: new APICallError6({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -3592,7 +4005,7 @@ var createJsonErrorResponseHandler = ({
     };
   }
 };
-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 +4013,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 +4032,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 +4048,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 +4119,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 +4130,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 +4183,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 +4196,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);
   }
 };
 
@@ -4135,6 +4622,7 @@ export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
+  EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
   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 +4644,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 +4671,7 @@ export {
   toolCaller as experimental_toolCaller,
   extractLines,
   extractResponseHeaders,
+  fetchWithValidatedEndpoint,
   fetchWithValidatedRedirects,
   filterNullable,
   generateId,
@@ -4197,6 +4690,7 @@ export {
   isNonNullable,
   isParsableJson,
   isProviderReference,
+  isProviderStreamError,
   isRecord,
   isSameOrigin,
   isUrlSupported,
@@ -4208,12 +4702,14 @@ export {
   mapReasoningToProviderBudget,
   mapReasoningToProviderEffort,
   mediaTypeToExtension,
+  normalizeBatchRequestCounts,
   normalizeHeaders,
   parseJSON,
   parseJsonEventStream,
   parseProviderOptions,
   postFormDataToApi,
   postJsonToApi,
+  postMultipartStreamToApi,
   postToApi,
   readResponseWithSizeLimit,
   readWebSocketMessageText,