@ai-sdk/provider-utils 5.0.0-beta.18 → 5.0.0-beta.19

package/dist/index.js

@@ -1,104 +1,3 @@
-"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,
-  isProviderReference: () => isProviderReference,
-  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,
-  resolveProviderReference: () => resolveProviderReference,
-  safeParseJSON: () => safeParseJSON,
-  safeValidateTypes: () => safeValidateTypes,
-  stripFileExtension: () => stripFileExtension,
-  tool: () => tool,
-  validateDownloadUrl: () => validateDownloadUrl,
-  validateTypes: () => validateTypes,
-  withUserAgentSuffix: () => withUserAgentSuffix,
-  withoutTrailingSlash: () => withoutTrailingSlash,
-  zodSchema: () => zodSchema
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/combine-headers.ts
 function combineHeaders(...headers) {
   return headers.reduce(
@@ -305,12 +204,12 @@ function convertToFormData(input, options = {}) {
 }
 
 // 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,
@@ -325,7 +224,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);
   }
 };
 
@@ -517,7 +416,7 @@ async function downloadBlob(url, options) {
 }
 
 // src/generate-id.ts
-var import_provider2 = require("@ai-sdk/provider");
+import { InvalidArgumentError } from "@ai-sdk/provider";
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -536,7 +435,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}".`
     });
@@ -560,10 +459,10 @@ function getErrorMessage(error) {
 }
 
 // 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) {
@@ -603,7 +502,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,
@@ -614,7 +513,7 @@ function handleFetchError({
     }
   }
   if (isBunNetworkError(error)) {
-    return new import_provider3.APICallError({
+    return new APICallError({
       message: `Cannot connect to API: ${error.message}`,
       cause: error,
       url,
@@ -678,7 +577,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.18" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.19" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -710,10 +609,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,
@@ -732,11 +631,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,
@@ -814,7 +713,7 @@ function isUrlSupported({
 }
 
 // src/load-api-key.ts
-var import_provider5 = require("@ai-sdk/provider");
+import { LoadAPIKeyError } from "@ai-sdk/provider";
 function loadApiKey({
   apiKey,
   environmentVariableName,
@@ -825,23 +724,23 @@ 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({
+    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.`
     });
   }
@@ -924,7 +823,7 @@ function loadOptionalSetting({
 }
 
 // src/load-setting.ts
-var import_provider6 = require("@ai-sdk/provider");
+import { LoadSettingError } from "@ai-sdk/provider";
 function loadSetting({
   settingValue,
   environmentVariableName,
@@ -935,23 +834,23 @@ function loadSetting({
     return settingValue;
   }
   if (settingValue != null) {
-    throw new import_provider6.LoadSettingError({
+    throw new LoadSettingError({
       message: `${description} setting must be a string.`
     });
   }
   if (typeof process === "undefined") {
-    throw new import_provider6.LoadSettingError({
+    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 import_provider6.LoadSettingError({
+    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 import_provider6.LoadSettingError({
+    throw new LoadSettingError({
       message: `${description} setting must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
     });
   }
@@ -972,7 +871,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*:/;
@@ -1024,11 +926,11 @@ 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) {
@@ -1100,7 +1002,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() {
@@ -1108,13 +1010,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"]
@@ -1289,7 +1191,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;
@@ -1637,20 +1541,20 @@ 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)) {
+  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)) {
+  } 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
@@ -2024,73 +1928,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);
@@ -2289,7 +2193,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
           })
@@ -2353,7 +2257,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;
 }
@@ -2373,13 +2277,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
     };
   }
@@ -2397,10 +2301,10 @@ async function parseJSON({
     }
     return 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({
@@ -2416,7 +2320,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
     };
   }
@@ -2431,12 +2335,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]") {
@@ -2449,7 +2355,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,
@@ -2463,7 +2369,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
@@ -2473,7 +2379,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,
@@ -2548,10 +2454,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,
@@ -2570,11 +2476,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,
@@ -2662,7 +2568,9 @@ function removeUndefinedEntries(record) {
 }
 
 // src/resolve-provider-reference.ts
-var import_provider12 = require("@ai-sdk/provider");
+import {
+  NoSuchProviderReferenceError
+} from "@ai-sdk/provider";
 function resolveProviderReference({
   reference,
   provider
@@ -2671,7 +2579,7 @@ function resolveProviderReference({
   if (id != null) {
     return id;
   }
-  throw new import_provider12.NoSuchProviderReferenceError({
+  throw new NoSuchProviderReferenceError({
     provider,
     reference
   });
@@ -2686,7 +2594,7 @@ async function resolve(value) {
 }
 
 // src/response-handler.ts
-var import_provider13 = require("@ai-sdk/provider");
+import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
 var createJsonErrorResponseHandler = ({
   errorSchema,
   errorToMessage,
@@ -2697,7 +2605,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new import_provider13.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2715,7 +2623,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new import_provider13.APICallError({
+      value: new APICallError4({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -2729,7 +2637,7 @@ var createJsonErrorResponseHandler = ({
   } catch (e) {
     return {
       responseHeaders,
-      value: new import_provider13.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2744,7 +2652,7 @@ var createJsonErrorResponseHandler = ({
 var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider13.EmptyResponseBodyError({});
+    throw new EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
@@ -2762,7 +2670,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new import_provider13.APICallError({
+    throw new APICallError4({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -2781,7 +2689,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
 var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (!response.body) {
-    throw new import_provider13.APICallError({
+    throw new APICallError4({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -2797,7 +2705,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
       value: new Uint8Array(buffer)
     };
   } catch (error) {
-    throw new import_provider13.APICallError({
+    throw new APICallError4({
       message: "Failed to read response as array buffer",
       url,
       requestBodyValues,
@@ -2813,7 +2721,7 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   const responseBody = await response.text();
   return {
     responseHeaders,
-    value: new import_provider13.APICallError({
+    value: new APICallError4({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -2860,13 +2768,14 @@ async function* executeTool({
 }
 
 // src/index.ts
-var import_stream2 = require("eventsource-parser/stream");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import {
+  EventSourceParserStream as EventSourceParserStream2
+} from "eventsource-parser/stream";
+export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
-  EventSourceParserStream,
+  EventSourceParserStream2 as EventSourceParserStream,
   VERSION,
   asSchema,
   combineHeaders,
@@ -2929,5 +2838,5 @@ var import_stream2 = require("eventsource-parser/stream");
   withUserAgentSuffix,
   withoutTrailingSlash,
   zodSchema
-});
+};
 //# sourceMappingURL=index.js.map