@ai-sdk/provider-utils 5.0.0-beta.9 → 5.0.0-canary.32

package/dist/index.js

@@ -1,101 +1,7 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DEFAULT_MAX_DOWNLOAD_SIZE: () => DEFAULT_MAX_DOWNLOAD_SIZE,
-  DelayedPromise: () => DelayedPromise,
-  DownloadError: () => DownloadError,
-  EventSourceParserStream: () => import_stream2.EventSourceParserStream,
-  VERSION: () => VERSION,
-  asSchema: () => asSchema,
-  combineHeaders: () => combineHeaders,
-  convertAsyncIteratorToReadableStream: () => convertAsyncIteratorToReadableStream,
-  convertBase64ToUint8Array: () => convertBase64ToUint8Array,
-  convertImageModelFileToDataUri: () => convertImageModelFileToDataUri,
-  convertToBase64: () => convertToBase64,
-  convertToFormData: () => convertToFormData,
-  convertUint8ArrayToBase64: () => convertUint8ArrayToBase64,
-  createBinaryResponseHandler: () => createBinaryResponseHandler,
-  createEventSourceResponseHandler: () => createEventSourceResponseHandler,
-  createIdGenerator: () => createIdGenerator,
-  createJsonErrorResponseHandler: () => createJsonErrorResponseHandler,
-  createJsonResponseHandler: () => createJsonResponseHandler,
-  createProviderToolFactory: () => createProviderToolFactory,
-  createProviderToolFactoryWithOutputSchema: () => createProviderToolFactoryWithOutputSchema,
-  createStatusCodeErrorResponseHandler: () => createStatusCodeErrorResponseHandler,
-  createToolNameMapping: () => createToolNameMapping,
-  delay: () => delay,
-  downloadBlob: () => downloadBlob,
-  dynamicTool: () => dynamicTool,
-  executeTool: () => executeTool,
-  extractResponseHeaders: () => extractResponseHeaders,
-  generateId: () => generateId,
-  getErrorMessage: () => getErrorMessage,
-  getFromApi: () => getFromApi,
-  getRuntimeEnvironmentUserAgent: () => getRuntimeEnvironmentUserAgent,
-  injectJsonInstructionIntoMessages: () => injectJsonInstructionIntoMessages,
-  isAbortError: () => isAbortError,
-  isCustomReasoning: () => isCustomReasoning,
-  isNonNullable: () => isNonNullable,
-  isParsableJson: () => isParsableJson,
-  isUrlSupported: () => isUrlSupported,
-  jsonSchema: () => jsonSchema,
-  lazySchema: () => lazySchema,
-  loadApiKey: () => loadApiKey,
-  loadOptionalSetting: () => loadOptionalSetting,
-  loadSetting: () => loadSetting,
-  mapReasoningToProviderBudget: () => mapReasoningToProviderBudget,
-  mapReasoningToProviderEffort: () => mapReasoningToProviderEffort,
-  mediaTypeToExtension: () => mediaTypeToExtension,
-  normalizeHeaders: () => normalizeHeaders,
-  parseJSON: () => parseJSON,
-  parseJsonEventStream: () => parseJsonEventStream,
-  parseProviderOptions: () => parseProviderOptions,
-  postFormDataToApi: () => postFormDataToApi,
-  postJsonToApi: () => postJsonToApi,
-  postToApi: () => postToApi,
-  readResponseWithSizeLimit: () => readResponseWithSizeLimit,
-  removeUndefinedEntries: () => removeUndefinedEntries,
-  resolve: () => resolve,
-  safeParseJSON: () => safeParseJSON,
-  safeValidateTypes: () => safeValidateTypes,
-  stripFileExtension: () => stripFileExtension,
-  tool: () => tool,
-  validateDownloadUrl: () => validateDownloadUrl,
-  validateTypes: () => validateTypes,
-  withUserAgentSuffix: () => withUserAgentSuffix,
-  withoutTrailingSlash: () => withoutTrailingSlash,
-  zodSchema: () => zodSchema
-});
-module.exports = __toCommonJS(index_exports);
+// src/as-array.ts
+function asArray(value) {
+  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+}
 
 // src/combine-headers.ts
 function combineHeaders(...headers) {
@@ -146,6 +52,68 @@ function convertAsyncIteratorToReadableStream(iterator) {
   });
 }
 
+// src/uint8-utils.ts
+var { btoa, atob } = globalThis;
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = atob(base64Url);
+  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]);
+  }
+  return btoa(latin1string);
+}
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
+
+// src/convert-inline-file-data-to-uint8-array.ts
+function convertInlineFileDataToUint8Array(data) {
+  if (data.type === "text") {
+    return new TextEncoder().encode(data.text);
+  }
+  if (data.data instanceof Uint8Array) {
+    return data.data;
+  }
+  if (data.data instanceof ArrayBuffer) {
+    return new Uint8Array(data.data);
+  }
+  return convertBase64ToUint8Array(data.data);
+}
+
+// src/convert-image-model-file-to-data-uri.ts
+function convertImageModelFileToDataUri(file) {
+  if (file.type === "url") return file.url;
+  return `data:${file.mediaType};base64,${typeof file.data === "string" ? file.data : convertUint8ArrayToBase64(file.data)}`;
+}
+
+// src/convert-to-form-data.ts
+function convertToFormData(input, options = {}) {
+  const { useArrayBrackets = true } = options;
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(input)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 1) {
+        formData.append(key, value[0]);
+        continue;
+      }
+      const arrayKey = useArrayBrackets ? `${key}[]` : key;
+      for (const item of value) {
+        formData.append(arrayKey, item);
+      }
+      continue;
+    }
+    formData.append(key, value);
+  }
+  return formData;
+}
+
 // src/create-tool-name-mapping.ts
 function createToolNameMapping({
   tools = [],
@@ -249,66 +217,285 @@ var DelayedPromise = class {
   }
 };
 
-// src/extract-response-headers.ts
-function extractResponseHeaders(response) {
-  return Object.fromEntries([...response.headers]);
-}
-
-// src/uint8-utils.ts
-var { btoa, atob } = globalThis;
-function convertBase64ToUint8Array(base64String) {
-  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
-  const latin1string = atob(base64Url);
-  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]);
+// src/detect-media-type.ts
+var imageMediaTypeSignatures = [
+  {
+    mediaType: "image/gif",
+    bytesPrefix: [71, 73, 70]
+    // GIF
+  },
+  {
+    mediaType: "image/png",
+    bytesPrefix: [137, 80, 78, 71]
+    // PNG
+  },
+  {
+    mediaType: "image/jpeg",
+    bytesPrefix: [255, 216]
+    // JPEG
+  },
+  {
+    mediaType: "image/webp",
+    bytesPrefix: [
+      82,
+      73,
+      70,
+      70,
+      // "RIFF"
+      null,
+      null,
+      null,
+      null,
+      // file size (variable)
+      87,
+      69,
+      66,
+      80
+      // "WEBP"
+    ]
+  },
+  {
+    mediaType: "image/bmp",
+    bytesPrefix: [66, 77]
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [73, 73, 42, 0]
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [77, 77, 0, 42]
+  },
+  {
+    mediaType: "image/avif",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      97,
+      118,
+      105,
+      102
+    ]
+  },
+  {
+    mediaType: "image/heic",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      104,
+      101,
+      105,
+      99
+    ]
   }
-  return btoa(latin1string);
-}
-function convertToBase64(value) {
-  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+];
+var documentMediaTypeSignatures = [
+  {
+    mediaType: "application/pdf",
+    bytesPrefix: [37, 80, 68, 70]
+    // %PDF
+  }
+];
+var audioMediaTypeSignatures = [
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 251]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 250]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 243]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 242]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 227]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 226]
+  },
+  {
+    mediaType: "audio/wav",
+    bytesPrefix: [
+      82,
+      // R
+      73,
+      // I
+      70,
+      // F
+      70,
+      // F
+      null,
+      null,
+      null,
+      null,
+      87,
+      // W
+      65,
+      // A
+      86,
+      // V
+      69
+      // E
+    ]
+  },
+  {
+    mediaType: "audio/ogg",
+    bytesPrefix: [79, 103, 103, 83]
+  },
+  {
+    mediaType: "audio/flac",
+    bytesPrefix: [102, 76, 97, 67]
+  },
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [64, 21, 0, 0]
+  },
+  {
+    mediaType: "audio/mp4",
+    bytesPrefix: [102, 116, 121, 112]
+  },
+  {
+    mediaType: "audio/webm",
+    bytesPrefix: [26, 69, 223, 163]
+  }
+];
+var videoMediaTypeSignatures = [
+  {
+    mediaType: "video/mp4",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      null,
+      102,
+      116,
+      121,
+      112
+      // ftyp
+    ]
+  },
+  {
+    mediaType: "video/webm",
+    bytesPrefix: [26, 69, 223, 163]
+    // EBML
+  },
+  {
+    mediaType: "video/quicktime",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      20,
+      102,
+      116,
+      121,
+      112,
+      113,
+      116
+      // ftypqt
+    ]
+  },
+  {
+    mediaType: "video/x-msvideo",
+    bytesPrefix: [82, 73, 70, 70]
+    // RIFF (AVI)
+  }
+];
+var stripID3 = (data) => {
+  const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
+  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
+  return bytes.slice(id3Size + 10);
+};
+function stripID3TagsIfPresent(data) {
+  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
+  data[1] === 68 && // 'D'
+  data[2] === 51;
+  return hasId3 ? stripID3(data) : data;
+}
+function detectMediaTypeBySignatures({
+  data,
+  signatures
+}) {
+  const processedData = stripID3TagsIfPresent(data);
+  const bytes = typeof processedData === "string" ? convertBase64ToUint8Array(
+    processedData.substring(0, Math.min(processedData.length, 24))
+  ) : processedData;
+  for (const signature of signatures) {
+    if (bytes.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
+      (byte, index) => byte === null || bytes[index] === byte
+    )) {
+      return signature.mediaType;
+    }
+  }
+  return void 0;
+}
+var topLevelSignatureTables = {
+  image: imageMediaTypeSignatures,
+  audio: audioMediaTypeSignatures,
+  video: videoMediaTypeSignatures,
+  application: documentMediaTypeSignatures
+};
+function detectMediaType({
+  data,
+  topLevelType
+}) {
+  if (topLevelType === void 0) {
+    return detectMediaTypeBySignatures({
+      data,
+      signatures: [
+        ...imageMediaTypeSignatures,
+        ...documentMediaTypeSignatures,
+        ...audioMediaTypeSignatures,
+        ...videoMediaTypeSignatures
+      ]
+    });
+  }
+  const signatures = topLevelSignatureTables[topLevelType];
+  if (signatures === void 0) {
+    return void 0;
+  }
+  return detectMediaTypeBySignatures({ data, signatures });
 }
-
-// src/convert-image-model-file-to-data-uri.ts
-function convertImageModelFileToDataUri(file) {
-  if (file.type === "url") return file.url;
-  return `data:${file.mediaType};base64,${typeof file.data === "string" ? file.data : convertUint8ArrayToBase64(file.data)}`;
+function getTopLevelMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
 }
-
-// src/convert-to-form-data.ts
-function convertToFormData(input, options = {}) {
-  const { useArrayBrackets = true } = options;
-  const formData = new FormData();
-  for (const [key, value] of Object.entries(input)) {
-    if (value == null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      if (value.length === 1) {
-        formData.append(key, value[0]);
-        continue;
-      }
-      const arrayKey = useArrayBrackets ? `${key}[]` : key;
-      for (const item of value) {
-        formData.append(arrayKey, item);
-      }
-      continue;
-    }
-    formData.append(key, value);
+function isFullMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  if (slashIndex === -1) {
+    return false;
   }
-  return formData;
+  const subtype = mediaType.substring(slashIndex + 1);
+  return subtype.length > 0 && subtype !== "*";
 }
 
 // src/download-error.ts
-var import_provider = require("@ai-sdk/provider");
+import { AISDKError } from "@ai-sdk/provider";
 var name = "AI_DownloadError";
 var marker = `vercel.ai.error.${name}`;
 var symbol = Symbol.for(marker);
 var _a, _b;
-var DownloadError = class extends (_b = import_provider.AISDKError, _a = symbol, _b) {
+var DownloadError = class extends (_b = AISDKError, _a = symbol, _b) {
   constructor({
     url,
     statusCode,
@@ -323,7 +510,7 @@ var DownloadError = class extends (_b = import_provider.AISDKError, _a = symbol,
     this.statusText = statusText;
   }
   static isInstance(error) {
-    return import_provider.AISDKError.hasMarker(error, marker);
+    return AISDKError.hasMarker(error, marker);
   }
 };
 
@@ -514,8 +701,18 @@ async function downloadBlob(url, options) {
   }
 }
 
+// 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);
+}
+
 // src/generate-id.ts
-var import_provider2 = require("@ai-sdk/provider");
+import { InvalidArgumentError } from "@ai-sdk/provider";
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -534,7 +731,7 @@ var createIdGenerator = ({
     return generator;
   }
   if (alphabet.includes(separator)) {
-    throw new import_provider2.InvalidArgumentError({
+    throw new InvalidArgumentError({
       argument: "separator",
       message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
     });
@@ -544,24 +741,13 @@ var createIdGenerator = ({
 var generateId = createIdGenerator();
 
 // src/get-error-message.ts
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
+import { getErrorMessage } from "@ai-sdk/provider";
 
 // src/get-from-api.ts
-var import_provider4 = require("@ai-sdk/provider");
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
 
 // src/handle-fetch-error.ts
-var import_provider3 = require("@ai-sdk/provider");
+import { APICallError } from "@ai-sdk/provider";
 
 // src/is-abort-error.ts
 function isAbortError(error) {
@@ -601,7 +787,7 @@ function handleFetchError({
   if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
     const cause = error.cause;
     if (cause != null) {
-      return new import_provider3.APICallError({
+      return new APICallError({
         message: `Cannot connect to API: ${cause.message}`,
         cause,
         url,
@@ -612,7 +798,7 @@ function handleFetchError({
     }
   }
   if (isBunNetworkError(error)) {
-    return new import_provider3.APICallError({
+    return new APICallError({
       message: `Cannot connect to API: ${error.message}`,
       cause: error,
       url,
@@ -676,7 +862,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.9" : "0.0.0-test";
+var VERSION = true ? "5.0.0-canary.32" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -708,10 +894,10 @@ var getFromApi = async ({
           requestBodyValues: {}
         });
       } catch (error) {
-        if (isAbortError(error) || import_provider4.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
           throw error;
         }
-        throw new import_provider4.APICallError({
+        throw new APICallError2({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -730,11 +916,11 @@ var getFromApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || import_provider4.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
           throw error;
         }
       }
-      throw new import_provider4.APICallError({
+      throw new APICallError2({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -787,11 +973,22 @@ function injectJsonInstructionIntoMessages({
   ];
 }
 
+// src/is-buffer.ts
+function isBuffer(value) {
+  var _a2, _b2;
+  return (_b2 = (_a2 = globalThis.Buffer) == null ? void 0 : _a2.isBuffer(value)) != null ? _b2 : false;
+}
+
 // src/is-non-nullable.ts
 function isNonNullable(value) {
   return value != null;
 }
 
+// src/is-provider-reference.ts
+function isProviderReference(data) {
+  return typeof data === "object" && data !== null && !(data instanceof Uint8Array) && !(data instanceof URL) && !(data instanceof ArrayBuffer) && !isBuffer(data) && !("type" in data);
+}
+
 // src/is-url-supported.ts
 function isUrlSupported({
   mediaType,
@@ -800,14 +997,23 @@ function isUrlSupported({
 }) {
   url = url.toLowerCase();
   mediaType = mediaType.toLowerCase();
+  const isTopLevelOnly = !mediaType.includes("/");
   return Object.entries(supportedUrls).map(([key, value]) => {
     const mediaType2 = key.toLowerCase();
     return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
-  }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
+  }).filter(({ mediaTypePrefix }) => {
+    if (mediaTypePrefix === "") {
+      return true;
+    }
+    if (isTopLevelOnly) {
+      return `${mediaType}/` === mediaTypePrefix;
+    }
+    return mediaType.startsWith(mediaTypePrefix);
+  }).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
 }
 
 // src/load-api-key.ts
-var import_provider5 = require("@ai-sdk/provider");
+import { LoadAPIKeyError } from "@ai-sdk/provider";
 function loadApiKey({
   apiKey,
   environmentVariableName,
@@ -818,29 +1024,82 @@ function loadApiKey({
     return apiKey;
   }
   if (apiKey != null) {
-    throw new import_provider5.LoadAPIKeyError({
+    throw new LoadAPIKeyError({
       message: `${description} API key must be a string.`
     });
   }
   if (typeof process === "undefined") {
-    throw new import_provider5.LoadAPIKeyError({
-      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+    throw new LoadAPIKeyError({
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables are not supported in this environment.`
     });
   }
   apiKey = process.env[environmentVariableName];
   if (apiKey == null) {
-    throw new import_provider5.LoadAPIKeyError({
+    throw new LoadAPIKeyError({
       message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
     });
   }
   if (typeof apiKey !== "string") {
-    throw new import_provider5.LoadAPIKeyError({
+    throw new LoadAPIKeyError({
       message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
     });
   }
   return apiKey;
 }
 
+// src/load-optional-setting.ts
+function loadOptionalSetting({
+  settingValue,
+  environmentVariableName
+}) {
+  if (typeof settingValue === "string") {
+    return settingValue;
+  }
+  if (settingValue != null || typeof process === "undefined") {
+    return void 0;
+  }
+  settingValue = process.env[environmentVariableName];
+  if (settingValue == null || typeof settingValue !== "string") {
+    return void 0;
+  }
+  return settingValue;
+}
+
+// src/load-setting.ts
+import { LoadSettingError } from "@ai-sdk/provider";
+function loadSetting({
+  settingValue,
+  environmentVariableName,
+  settingName,
+  description
+}) {
+  if (typeof settingValue === "string") {
+    return settingValue;
+  }
+  if (settingValue != null) {
+    throw new LoadSettingError({
+      message: `${description} setting must be a string.`
+    });
+  }
+  if (typeof process === "undefined") {
+    throw new LoadSettingError({
+      message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables are not supported in this environment.`
+    });
+  }
+  settingValue = process.env[environmentVariableName];
+  if (settingValue == null) {
+    throw new LoadSettingError({
+      message: `${description} setting is missing. Pass it using the '${settingName}' parameter or the ${environmentVariableName} environment variable.`
+    });
+  }
+  if (typeof settingValue !== "string") {
+    throw new LoadSettingError({
+      message: `${description} setting must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
+    });
+  }
+  return settingValue;
+}
+
 // src/map-reasoning-to-provider.ts
 function isCustomReasoning(reasoning) {
   return reasoning !== void 0 && reasoning !== "provider-default";
@@ -898,59 +1157,6 @@ function mapReasoningToProviderBudget({
   );
 }
 
-// src/load-optional-setting.ts
-function loadOptionalSetting({
-  settingValue,
-  environmentVariableName
-}) {
-  if (typeof settingValue === "string") {
-    return settingValue;
-  }
-  if (settingValue != null || typeof process === "undefined") {
-    return void 0;
-  }
-  settingValue = process.env[environmentVariableName];
-  if (settingValue == null || typeof settingValue !== "string") {
-    return void 0;
-  }
-  return settingValue;
-}
-
-// src/load-setting.ts
-var import_provider6 = require("@ai-sdk/provider");
-function loadSetting({
-  settingValue,
-  environmentVariableName,
-  settingName,
-  description
-}) {
-  if (typeof settingValue === "string") {
-    return settingValue;
-  }
-  if (settingValue != null) {
-    throw new import_provider6.LoadSettingError({
-      message: `${description} setting must be a string.`
-    });
-  }
-  if (typeof process === "undefined") {
-    throw new import_provider6.LoadSettingError({
-      message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables is not supported in this environment.`
-    });
-  }
-  settingValue = process.env[environmentVariableName];
-  if (settingValue == null) {
-    throw new import_provider6.LoadSettingError({
-      message: `${description} setting is missing. Pass it using the '${settingName}' parameter or the ${environmentVariableName} environment variable.`
-    });
-  }
-  if (typeof settingValue !== "string") {
-    throw new import_provider6.LoadSettingError({
-      message: `${description} setting must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
-    });
-  }
-  return settingValue;
-}
-
 // src/media-type-to-extension.ts
 function mediaTypeToExtension(mediaType) {
   var _a2;
@@ -965,7 +1171,10 @@ function mediaTypeToExtension(mediaType) {
 }
 
 // src/parse-json.ts
-var import_provider9 = require("@ai-sdk/provider");
+import {
+  JSONParseError,
+  TypeValidationError as TypeValidationError3
+} from "@ai-sdk/provider";
 
 // src/secure-json-parse.ts
 var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
@@ -1017,11 +1226,13 @@ function secureJsonParse(text) {
 }
 
 // src/validate-types.ts
-var import_provider8 = require("@ai-sdk/provider");
+import {
+  TypeValidationError as TypeValidationError2
+} from "@ai-sdk/provider";
 
 // src/schema.ts
-var import_provider7 = require("@ai-sdk/provider");
-var z4 = __toESM(require("zod/v4"));
+import { TypeValidationError } from "@ai-sdk/provider";
+import * as z4 from "zod/v4";
 
 // src/add-additional-properties-to-json-schema.ts
 function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
@@ -1093,7 +1304,7 @@ var getDefaultOptions = (options) => typeof options === "string" ? {
 };
 
 // src/to-json-schema/zod3-to-json-schema/select-parser.ts
-var import_v33 = require("zod/v3");
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
 
 // src/to-json-schema/zod3-to-json-schema/parsers/any.ts
 function parseAnyDef() {
@@ -1101,13 +1312,13 @@ function parseAnyDef() {
 }
 
 // src/to-json-schema/zod3-to-json-schema/parsers/array.ts
-var import_v3 = require("zod/v3");
+import { ZodFirstPartyTypeKind } from "zod/v3";
 function parseArrayDef(def, refs) {
   var _a2, _b2, _c;
   const res = {
     type: "array"
   };
-  if (((_a2 = def.type) == null ? void 0 : _a2._def) && ((_c = (_b2 = def.type) == null ? void 0 : _b2._def) == null ? void 0 : _c.typeName) !== import_v3.ZodFirstPartyTypeKind.ZodAny) {
+  if (((_a2 = def.type) == null ? void 0 : _a2._def) && ((_c = (_b2 = def.type) == null ? void 0 : _b2._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -1177,7 +1388,7 @@ function parseDateDef(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+      anyOf: strategy.map((item) => parseDateDef(def, refs, item))
     };
   }
   switch (strategy) {
@@ -1258,7 +1469,7 @@ function parseIntersectionDef(def, refs) {
     } else {
       let nestedSchema = schema;
       if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
+        const { additionalProperties: _additionalProperties, ...rest } = schema;
         nestedSchema = rest;
       }
       mergedAllOf.push(nestedSchema);
@@ -1282,7 +1493,9 @@ function parseLiteralDef(def) {
 }
 
 // src/to-json-schema/zod3-to-json-schema/parsers/record.ts
-var import_v32 = require("zod/v3");
+import {
+  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
+} from "zod/v3";
 
 // src/to-json-schema/zod3-to-json-schema/parsers/string.ts
 var emojiRegex = void 0;
@@ -1630,21 +1843,21 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     })) != null ? _a2 : refs.allowedAdditionalProperties
   };
-  if (((_b2 = def.keyType) == null ? void 0 : _b2._def.typeName) === import_v32.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+  if (((_b2 = def.keyType) == null ? void 0 : _b2._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.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) === import_v32.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v32.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v32.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef(
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+    const { type: _type, ...keyType } = parseBrandedDef(
       def.keyType._def,
       refs
     );
@@ -2017,73 +2230,73 @@ var parseReadonlyDef = (def, refs) => {
 // src/to-json-schema/zod3-to-json-schema/select-parser.ts
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v33.ZodFirstPartyTypeKind.ZodString:
+    case ZodFirstPartyTypeKind3.ZodString:
       return parseStringDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodNumber:
+    case ZodFirstPartyTypeKind3.ZodNumber:
       return parseNumberDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodObject:
+    case ZodFirstPartyTypeKind3.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodBigInt:
+    case ZodFirstPartyTypeKind3.ZodBigInt:
       return parseBigintDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodBoolean:
+    case ZodFirstPartyTypeKind3.ZodBoolean:
       return parseBooleanDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodDate:
+    case ZodFirstPartyTypeKind3.ZodDate:
       return parseDateDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodUndefined:
+    case ZodFirstPartyTypeKind3.ZodUndefined:
       return parseUndefinedDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodNull:
+    case ZodFirstPartyTypeKind3.ZodNull:
       return parseNullDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodArray:
+    case ZodFirstPartyTypeKind3.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v33.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case ZodFirstPartyTypeKind3.ZodUnion:
+    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodIntersection:
+    case ZodFirstPartyTypeKind3.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodTuple:
+    case ZodFirstPartyTypeKind3.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodRecord:
+    case ZodFirstPartyTypeKind3.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodLiteral:
+    case ZodFirstPartyTypeKind3.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodEnum:
+    case ZodFirstPartyTypeKind3.ZodEnum:
       return parseEnumDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case ZodFirstPartyTypeKind3.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodNullable:
+    case ZodFirstPartyTypeKind3.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodOptional:
+    case ZodFirstPartyTypeKind3.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodMap:
+    case ZodFirstPartyTypeKind3.ZodMap:
       return parseMapDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodSet:
+    case ZodFirstPartyTypeKind3.ZodSet:
       return parseSetDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodLazy:
+    case ZodFirstPartyTypeKind3.ZodLazy:
       return () => def.getter()._def;
-    case import_v33.ZodFirstPartyTypeKind.ZodPromise:
+    case ZodFirstPartyTypeKind3.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v33.ZodFirstPartyTypeKind.ZodNever:
+    case ZodFirstPartyTypeKind3.ZodNaN:
+    case ZodFirstPartyTypeKind3.ZodNever:
       return parseNeverDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodEffects:
+    case ZodFirstPartyTypeKind3.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodAny:
+    case ZodFirstPartyTypeKind3.ZodAny:
       return parseAnyDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodUnknown:
+    case ZodFirstPartyTypeKind3.ZodUnknown:
       return parseUnknownDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodDefault:
+    case ZodFirstPartyTypeKind3.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodBranded:
+    case ZodFirstPartyTypeKind3.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodReadonly:
+    case ZodFirstPartyTypeKind3.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodCatch:
+    case ZodFirstPartyTypeKind3.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodPipeline:
+    case ZodFirstPartyTypeKind3.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v33.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v33.ZodFirstPartyTypeKind.ZodSymbol:
+    case ZodFirstPartyTypeKind3.ZodFunction:
+    case ZodFirstPartyTypeKind3.ZodVoid:
+    case ZodFirstPartyTypeKind3.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -2282,7 +2495,7 @@ function standardSchema(standardSchema2) {
         const result = await standardSchema2["~standard"].validate(value);
         return "value" in result ? { success: true, value: result.value } : {
           success: false,
-          error: new import_provider7.TypeValidationError({
+          error: new TypeValidationError({
             value,
             cause: result.issues
           })
@@ -2346,7 +2559,7 @@ async function validateTypes({
 }) {
   const result = await safeValidateTypes({ value, schema, context });
   if (!result.success) {
-    throw import_provider8.TypeValidationError.wrap({ value, cause: result.error, context });
+    throw TypeValidationError2.wrap({ value, cause: result.error, context });
   }
   return result.value;
 }
@@ -2366,13 +2579,13 @@ async function safeValidateTypes({
     }
     return {
       success: false,
-      error: import_provider8.TypeValidationError.wrap({ value, cause: result.error, context }),
+      error: TypeValidationError2.wrap({ value, cause: result.error, context }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: import_provider8.TypeValidationError.wrap({ value, cause: error, context }),
+      error: TypeValidationError2.wrap({ value, cause: error, context }),
       rawValue: value
     };
   }
@@ -2388,12 +2601,12 @@ async function parseJSON({
     if (schema == null) {
       return value;
     }
-    return validateTypes({ value, schema });
+    return await validateTypes({ value, schema });
   } catch (error) {
-    if (import_provider9.JSONParseError.isInstance(error) || import_provider9.TypeValidationError.isInstance(error)) {
+    if (JSONParseError.isInstance(error) || TypeValidationError3.isInstance(error)) {
       throw error;
     }
-    throw new import_provider9.JSONParseError({ text, cause: error });
+    throw new JSONParseError({ text, cause: error });
   }
 }
 async function safeParseJSON({
@@ -2409,7 +2622,7 @@ async function safeParseJSON({
   } catch (error) {
     return {
       success: false,
-      error: import_provider9.JSONParseError.isInstance(error) ? error : new import_provider9.JSONParseError({ text, cause: error }),
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
       rawValue: void 0
     };
   }
@@ -2424,12 +2637,14 @@ function isParsableJson(input) {
 }
 
 // src/parse-json-event-stream.ts
-var import_stream = require("eventsource-parser/stream");
+import {
+  EventSourceParserStream
+} from "eventsource-parser/stream";
 function parseJsonEventStream({
   stream,
   schema
 }) {
-  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new import_stream.EventSourceParserStream()).pipeThrough(
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
     new TransformStream({
       async transform({ data }, controller) {
         if (data === "[DONE]") {
@@ -2442,7 +2657,7 @@ function parseJsonEventStream({
 }
 
 // src/parse-provider-options.ts
-var import_provider10 = require("@ai-sdk/provider");
+import { InvalidArgumentError as InvalidArgumentError2 } from "@ai-sdk/provider";
 async function parseProviderOptions({
   provider,
   providerOptions,
@@ -2456,7 +2671,7 @@ async function parseProviderOptions({
     schema
   });
   if (!parsedProviderOptions.success) {
-    throw new import_provider10.InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "providerOptions",
       message: `invalid ${provider} provider options`,
       cause: parsedProviderOptions.error
@@ -2466,7 +2681,7 @@ async function parseProviderOptions({
 }
 
 // src/post-to-api.ts
-var import_provider11 = require("@ai-sdk/provider");
+import { APICallError as APICallError3 } from "@ai-sdk/provider";
 var getOriginalFetch2 = () => globalThis.fetch;
 var postJsonToApi = async ({
   url,
@@ -2476,7 +2691,7 @@ var postJsonToApi = async ({
   successfulResponseHandler,
   abortSignal,
   fetch: fetch2
-}) => postToApi({
+}) => await postToApi({
   url,
   headers: {
     "Content-Type": "application/json",
@@ -2499,7 +2714,7 @@ var postFormDataToApi = async ({
   successfulResponseHandler,
   abortSignal,
   fetch: fetch2
-}) => postToApi({
+}) => await postToApi({
   url,
   headers,
   body: {
@@ -2541,10 +2756,10 @@ var postToApi = async ({
           requestBodyValues: body.values
         });
       } catch (error) {
-        if (isAbortError(error) || import_provider11.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
-        throw new import_provider11.APICallError({
+        throw new APICallError3({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -2563,11 +2778,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || import_provider11.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
       }
-      throw new import_provider11.APICallError({
+      throw new APICallError3({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -2589,8 +2804,8 @@ function dynamicTool(tool2) {
   return { ...tool2, type: "dynamic" };
 }
 
-// src/provider-tool-factory.ts
-function createProviderToolFactory({
+// src/provider-defined-tool-factory.ts
+function createProviderDefinedToolFactory({
   id,
   inputSchema
 }) {
@@ -2605,6 +2820,7 @@ function createProviderToolFactory({
     ...args
   }) => tool({
     type: "provider",
+    isProviderExecuted: false,
     id,
     args,
     inputSchema,
@@ -2617,11 +2833,10 @@ function createProviderToolFactory({
     onInputAvailable
   });
 }
-function createProviderToolFactoryWithOutputSchema({
+function createProviderDefinedToolFactoryWithOutputSchema({
   id,
   inputSchema,
-  outputSchema,
-  supportsDeferredResults
+  outputSchema
 }) {
   return ({
     execute,
@@ -2633,6 +2848,7 @@ function createProviderToolFactoryWithOutputSchema({
     ...args
   }) => tool({
     type: "provider",
+    isProviderExecuted: false,
     id,
     args,
     inputSchema,
@@ -2642,6 +2858,31 @@ function createProviderToolFactoryWithOutputSchema({
     toModelOutput,
     onInputStart,
     onInputDelta,
+    onInputAvailable
+  });
+}
+
+// src/provider-executed-tool-factory.ts
+function createProviderExecutedToolFactory({
+  id,
+  inputSchema,
+  outputSchema,
+  supportsDeferredResults
+}) {
+  return ({
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }) => tool({
+    type: "provider",
+    isProviderExecuted: true,
+    id,
+    args,
+    inputSchema,
+    outputSchema,
+    onInputStart,
+    onInputDelta,
     onInputAvailable,
     supportsDeferredResults
   });
@@ -2662,8 +2903,53 @@ async function resolve(value) {
   return Promise.resolve(value);
 }
 
+// src/resolve-full-media-type.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+function resolveFullMediaType({
+  part
+}) {
+  if (isFullMediaType(part.mediaType)) {
+    return part.mediaType;
+  }
+  if (part.data.type === "data") {
+    const detected = detectMediaType({
+      data: part.data.data,
+      topLevelType: getTopLevelMediaType(part.mediaType)
+    });
+    if (detected) {
+      return detected;
+    }
+    throw new UnsupportedFunctionalityError({
+      functionality: `file of media type "${part.mediaType}" must specify subtype since it could not be auto-detected`
+    });
+  }
+  throw new UnsupportedFunctionalityError({
+    functionality: `file of media type "${part.mediaType}" must specify subtype since it is not passed as inline bytes`
+  });
+}
+
+// src/resolve-provider-reference.ts
+import {
+  NoSuchProviderReferenceError
+} from "@ai-sdk/provider";
+function resolveProviderReference({
+  reference,
+  provider
+}) {
+  const id = reference[provider];
+  if (id != null) {
+    return id;
+  }
+  throw new NoSuchProviderReferenceError({
+    provider,
+    reference
+  });
+}
+
 // src/response-handler.ts
-var import_provider12 = require("@ai-sdk/provider");
+import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
 var createJsonErrorResponseHandler = ({
   errorSchema,
   errorToMessage,
@@ -2674,7 +2960,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2692,7 +2978,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -2703,10 +2989,10 @@ var createJsonErrorResponseHandler = ({
         isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
       })
     };
-  } catch (parseError) {
+  } catch (e) {
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2721,7 +3007,7 @@ var createJsonErrorResponseHandler = ({
 var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider12.EmptyResponseBodyError({});
+    throw new EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
@@ -2739,7 +3025,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new import_provider12.APICallError({
+    throw new APICallError4({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -2758,7 +3044,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
 var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (!response.body) {
-    throw new import_provider12.APICallError({
+    throw new APICallError4({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -2774,7 +3060,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
       value: new Uint8Array(buffer)
     };
   } catch (error) {
-    throw new import_provider12.APICallError({
+    throw new APICallError4({
       message: "Failed to read response as array buffer",
       url,
       requestBodyValues,
@@ -2790,7 +3076,7 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   const responseBody = await response.text();
   return {
     responseHeaders,
-    value: new import_provider12.APICallError({
+    value: new APICallError4({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -2801,6 +3087,185 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   };
 };
 
+// src/is-json-serializable.ts
+function isJSONSerializable(value) {
+  if (value === null || value === void 0) return true;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") return true;
+  if (type === "function" || type === "symbol" || type === "bigint")
+    return false;
+  if (Array.isArray(value)) {
+    return value.every(isJSONSerializable);
+  }
+  if (Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.values(value).every(
+      isJSONSerializable
+    );
+  }
+  return false;
+}
+
+// src/serialize-model-options.ts
+function serializeModelOptions(options) {
+  const serializableConfig = {};
+  for (const [key, value] of Object.entries(options.config)) {
+    if (key === "headers") {
+      const resolvedHeaders = resolveSync(value);
+      if (isJSONSerializable(resolvedHeaders)) {
+        serializableConfig[key] = resolvedHeaders;
+      }
+    } else if (isJSONSerializable(value)) {
+      serializableConfig[key] = value;
+    }
+  }
+  return { modelId: options.modelId, config: serializableConfig };
+}
+function resolveSync(value) {
+  let next = value;
+  if (typeof value === "function") {
+    next = value();
+  }
+  if (next instanceof Promise) {
+    throw new Error("Promise returned from resolveSync");
+  }
+  return next;
+}
+
+// src/streaming-tool-call-tracker.ts
+import {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+var StreamingToolCallTracker = class {
+  constructor(controller, options = {}) {
+    this.toolCalls = [];
+    var _a2, _b2;
+    this.controller = controller;
+    this._generateId = (_a2 = options.generateId) != null ? _a2 : generateId;
+    this.typeValidation = (_b2 = options.typeValidation) != null ? _b2 : "none";
+    this.extractMetadata = options.extractMetadata;
+    this.buildToolCallProviderMetadata = options.buildToolCallProviderMetadata;
+  }
+  /**
+   * Process a tool call delta from a streaming response chunk.
+   * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
+   * events as appropriate.
+   */
+  processDelta(toolCallDelta) {
+    var _a2;
+    const index = (_a2 = toolCallDelta.index) != null ? _a2 : this.toolCalls.length;
+    if (this.toolCalls[index] == null) {
+      this.processNewToolCall(index, toolCallDelta);
+    } else {
+      this.processExistingToolCall(index, toolCallDelta);
+    }
+  }
+  /**
+   * Finalize any unfinished tool calls. Should be called during the stream's
+   * flush handler to ensure all tool calls are properly completed.
+   */
+  flush() {
+    for (const toolCall of this.toolCalls) {
+      if (!toolCall.hasFinished) {
+        this.finishToolCall(toolCall);
+      }
+    }
+  }
+  processNewToolCall(index, toolCallDelta) {
+    var _a2, _b2, _c;
+    if (this.typeValidation === "required") {
+      if (toolCallDelta.type !== "function") {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`
+        });
+      }
+    } else if (this.typeValidation === "if-present") {
+      if (toolCallDelta.type != null && toolCallDelta.type !== "function") {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`
+        });
+      }
+    }
+    if (toolCallDelta.id == null) {
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: `Expected 'id' to be a string.`
+      });
+    }
+    if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.name) == null) {
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: `Expected 'function.name' to be a string.`
+      });
+    }
+    this.controller.enqueue({
+      type: "tool-input-start",
+      id: toolCallDelta.id,
+      toolName: toolCallDelta.function.name
+    });
+    const metadata = (_b2 = this.extractMetadata) == null ? void 0 : _b2.call(this, toolCallDelta);
+    this.toolCalls[index] = {
+      id: toolCallDelta.id,
+      type: "function",
+      function: {
+        name: toolCallDelta.function.name,
+        arguments: (_c = toolCallDelta.function.arguments) != null ? _c : ""
+      },
+      hasFinished: false,
+      metadata
+    };
+    const toolCall = this.toolCalls[index];
+    if (toolCall.function.arguments.length > 0) {
+      this.controller.enqueue({
+        type: "tool-input-delta",
+        id: toolCall.id,
+        delta: toolCall.function.arguments
+      });
+    }
+    if (isParsableJson(toolCall.function.arguments)) {
+      this.finishToolCall(toolCall);
+    }
+  }
+  processExistingToolCall(index, toolCallDelta) {
+    var _a2;
+    const toolCall = this.toolCalls[index];
+    if (toolCall.hasFinished) {
+      return;
+    }
+    if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.arguments) != null) {
+      toolCall.function.arguments += toolCallDelta.function.arguments;
+      this.controller.enqueue({
+        type: "tool-input-delta",
+        id: toolCall.id,
+        delta: toolCallDelta.function.arguments
+      });
+    }
+    if (isParsableJson(toolCall.function.arguments)) {
+      this.finishToolCall(toolCall);
+    }
+  }
+  finishToolCall(toolCall) {
+    var _a2, _b2;
+    this.controller.enqueue({
+      type: "tool-input-end",
+      id: toolCall.id
+    });
+    const providerMetadata = (_a2 = this.buildToolCallProviderMetadata) == null ? void 0 : _a2.call(
+      this,
+      toolCall.metadata
+    );
+    this.controller.enqueue({
+      type: "tool-call",
+      toolCallId: (_b2 = toolCall.id) != null ? _b2 : this._generateId(),
+      toolName: toolCall.function.name,
+      input: toolCall.function.arguments,
+      ...providerMetadata ? { providerMetadata } : {}
+    });
+    toolCall.hasFinished = true;
+  }
+};
+
 // src/strip-file-extension.ts
 function stripFileExtension(filename) {
   const firstDotIndex = filename.indexOf(".");
@@ -2819,11 +3284,11 @@ function isAsyncIterable(obj) {
 
 // src/types/execute-tool.ts
 async function* executeTool({
-  execute,
+  tool: tool2,
   input,
   options
 }) {
-  const result = execute(input, options);
+  const result = tool2.execute(input, options);
   if (isAsyncIterable(result)) {
     let lastOutput;
     for await (const output of result) {
@@ -2836,20 +3301,32 @@ async function* executeTool({
   }
 }
 
+// src/types/executable-tool.ts
+function isExecutableTool(tool2) {
+  return tool2 != null && typeof tool2.execute === "function";
+}
+
 // src/index.ts
-var import_stream2 = require("eventsource-parser/stream");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+import {
+  EventSourceParserStream as EventSourceParserStream2
+} from "eventsource-parser/stream";
+export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
-  EventSourceParserStream,
+  EventSourceParserStream2 as EventSourceParserStream,
+  StreamingToolCallTracker,
   VERSION,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+  asArray,
   asSchema,
   combineHeaders,
   convertAsyncIteratorToReadableStream,
   convertBase64ToUint8Array,
   convertImageModelFileToDataUri,
+  convertInlineFileDataToUint8Array,
   convertToBase64,
   convertToFormData,
   convertUint8ArrayToBase64,
@@ -2858,24 +3335,32 @@ var import_stream2 = require("eventsource-parser/stream");
   createIdGenerator,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
-  createProviderToolFactory,
-  createProviderToolFactoryWithOutputSchema,
+  createProviderDefinedToolFactory,
+  createProviderDefinedToolFactoryWithOutputSchema,
+  createProviderExecutedToolFactory,
   createStatusCodeErrorResponseHandler,
   createToolNameMapping,
   delay,
+  detectMediaType,
   downloadBlob,
   dynamicTool,
   executeTool,
   extractResponseHeaders,
+  filterNullable,
   generateId,
   getErrorMessage,
   getFromApi,
   getRuntimeEnvironmentUserAgent,
+  getTopLevelMediaType,
   injectJsonInstructionIntoMessages,
   isAbortError,
+  isBuffer,
   isCustomReasoning,
+  isExecutableTool,
+  isFullMediaType,
   isNonNullable,
   isParsableJson,
+  isProviderReference,
   isUrlSupported,
   jsonSchema,
   lazySchema,
@@ -2895,8 +3380,11 @@ var import_stream2 = require("eventsource-parser/stream");
   readResponseWithSizeLimit,
   removeUndefinedEntries,
   resolve,
+  resolveFullMediaType,
+  resolveProviderReference,
   safeParseJSON,
   safeValidateTypes,
+  serializeModelOptions,
   stripFileExtension,
   tool,
   validateDownloadUrl,
@@ -2904,5 +3392,5 @@ var import_stream2 = require("eventsource-parser/stream");
   withUserAgentSuffix,
   withoutTrailingSlash,
   zodSchema
-});
+};
 //# sourceMappingURL=index.js.map