@ai-sdk/provider-utils 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/index.js

@@ -1,99 +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,
-  isNonNullable: () => isNonNullable,
-  isParsableJson: () => isParsableJson,
-  isUrlSupported: () => isUrlSupported,
-  jsonSchema: () => jsonSchema,
-  lazySchema: () => lazySchema,
-  loadApiKey: () => loadApiKey,
-  loadOptionalSetting: () => loadOptionalSetting,
-  loadSetting: () => loadSetting,
-  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/combine-headers.ts
 function combineHeaders(...headers) {
   return headers.reduce(
@@ -143,33 +47,76 @@ 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-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 = [],
-  providerToolNames,
-  resolveProviderToolName
+  providerToolNames
 }) {
-  var _a2;
   const customToolNameToProviderToolName = {};
   const providerToolNameToCustomToolName = {};
   for (const tool2 of tools) {
-    if (tool2.type === "provider") {
-      const providerToolName = (_a2 = resolveProviderToolName == null ? void 0 : resolveProviderToolName(tool2)) != null ? _a2 : tool2.id in providerToolNames ? providerToolNames[tool2.id] : void 0;
-      if (providerToolName == null) {
-        continue;
-      }
+    if (tool2.type === "provider" && tool2.id in providerToolNames) {
+      const providerToolName = providerToolNames[tool2.id];
       customToolNameToProviderToolName[tool2.name] = providerToolName;
       providerToolNameToCustomToolName[providerToolName] = tool2.name;
     }
   }
   return {
     toProviderToolName: (customToolName) => {
-      var _a3;
-      return (_a3 = customToolNameToProviderToolName[customToolName]) != null ? _a3 : customToolName;
+      var _a2;
+      return (_a2 = customToolNameToProviderToolName[customToolName]) != null ? _a2 : customToolName;
     },
     toCustomToolName: (providerToolName) => {
-      var _a3;
-      return (_a3 = providerToolNameToCustomToolName[providerToolName]) != null ? _a3 : providerToolName;
+      var _a2;
+      return (_a2 = providerToolNameToCustomToolName[providerToolName]) != null ? _a2 : providerToolName;
     }
   };
 }
@@ -251,66 +198,13 @@ 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]);
-  }
-  return btoa(latin1string);
-}
-function convertToBase64(value) {
-  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
-}
-
-// 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/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 +219,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);
   }
 };
 
@@ -395,10 +289,13 @@ function validateDownloadUrl(url) {
       message: `Invalid URL: ${url}`
     });
   }
+  if (parsed.protocol === "data:") {
+    return;
+  }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
     throw new DownloadError({
       url,
-      message: `URL scheme must be http or https, got ${parsed.protocol}`
+      message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
     });
   }
   const hostname = parsed.hostname;
@@ -513,8 +410,13 @@ async function downloadBlob(url, options) {
   }
 }
 
+// src/extract-response-headers.ts
+function extractResponseHeaders(response) {
+  return Object.fromEntries([...response.headers]);
+}
+
 // src/generate-id.ts
-var import_provider2 = require("@ai-sdk/provider");
+import { InvalidArgumentError } from "@ai-sdk/provider";
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -533,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}".`
     });
@@ -551,16 +453,16 @@ function getErrorMessage(error) {
     return error;
   }
   if (error instanceof Error) {
-    return error.message;
+    return error.toString();
   }
   return JSON.stringify(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) {
@@ -600,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,
@@ -611,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,
@@ -675,7 +577,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.2" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.20" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -707,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,
@@ -729,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,
@@ -791,6 +693,11 @@ function isNonNullable(value) {
   return value != null;
 }
 
+// src/is-provider-reference.ts
+function isProviderReference(data) {
+  return typeof data === "object" && !(data instanceof Uint8Array) && !(data instanceof URL);
+}
+
 // src/is-url-supported.ts
 function isUrlSupported({
   mediaType,
@@ -806,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,
@@ -817,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({
-      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.`
     });
   }
@@ -859,7 +766,7 @@ function loadOptionalSetting({
 }
 
 // src/load-setting.ts
-var import_provider6 = require("@ai-sdk/provider");
+import { LoadSettingError } from "@ai-sdk/provider";
 function loadSetting({
   settingValue,
   environmentVariableName,
@@ -870,29 +777,86 @@ 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({
-      message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables is not supported in this environment.`
+    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.`
     });
   }
   return settingValue;
 }
 
+// src/map-reasoning-to-provider.ts
+function isCustomReasoning(reasoning) {
+  return reasoning !== void 0 && reasoning !== "provider-default";
+}
+function mapReasoningToProviderEffort({
+  reasoning,
+  effortMap,
+  warnings
+}) {
+  const mapped = effortMap[reasoning];
+  if (mapped == null) {
+    warnings.push({
+      type: "unsupported",
+      feature: "reasoning",
+      details: `reasoning "${reasoning}" is not supported by this model.`
+    });
+    return void 0;
+  }
+  if (mapped !== reasoning) {
+    warnings.push({
+      type: "compatibility",
+      feature: "reasoning",
+      details: `reasoning "${reasoning}" is not directly supported by this model. mapped to effort "${mapped}".`
+    });
+  }
+  return mapped;
+}
+var DEFAULT_REASONING_BUDGET_PERCENTAGES = {
+  minimal: 0.02,
+  low: 0.1,
+  medium: 0.3,
+  high: 0.6,
+  xhigh: 0.9
+};
+function mapReasoningToProviderBudget({
+  reasoning,
+  maxOutputTokens,
+  maxReasoningBudget,
+  minReasoningBudget = 1024,
+  budgetPercentages = DEFAULT_REASONING_BUDGET_PERCENTAGES,
+  warnings
+}) {
+  const pct = budgetPercentages[reasoning];
+  if (pct == null) {
+    warnings.push({
+      type: "unsupported",
+      feature: "reasoning",
+      details: `reasoning "${reasoning}" is not supported by this model.`
+    });
+    return void 0;
+  }
+  return Math.min(
+    maxReasoningBudget,
+    Math.max(minReasoningBudget, Math.round(maxOutputTokens * pct))
+  );
+}
+
 // src/media-type-to-extension.ts
 function mediaTypeToExtension(mediaType) {
   var _a2;
@@ -907,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*:/;
@@ -959,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) {
@@ -1035,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() {
@@ -1043,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"]
@@ -1119,7 +1086,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) {
@@ -1200,7 +1167,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);
@@ -1224,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;
@@ -1572,21 +1541,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
     );
@@ -1959,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);
@@ -2224,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
           })
@@ -2288,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;
 }
@@ -2308,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
     };
   }
@@ -2332,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({
@@ -2351,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
     };
   }
@@ -2366,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]") {
@@ -2384,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,
@@ -2398,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
@@ -2408,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,
@@ -2483,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,
@@ -2505,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,
@@ -2604,8 +2575,26 @@ async function resolve(value) {
   return Promise.resolve(value);
 }
 
+// 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,
@@ -2616,7 +2605,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2634,7 +2623,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -2645,10 +2634,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,
@@ -2663,7 +2652,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,
@@ -2681,7 +2670,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,
@@ -2700,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_provider12.APICallError({
+    throw new APICallError4({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -2716,7 +2705,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,
@@ -2732,7 +2721,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,
@@ -2743,6 +2732,50 @@ 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/strip-file-extension.ts
 function stripFileExtension(filename) {
   const firstDotIndex = filename.indexOf(".");
@@ -2779,14 +2812,18 @@ 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 { 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,
   VERSION,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
   asSchema,
   combineHeaders,
   convertAsyncIteratorToReadableStream,
@@ -2815,14 +2852,18 @@ var import_stream2 = require("eventsource-parser/stream");
   getRuntimeEnvironmentUserAgent,
   injectJsonInstructionIntoMessages,
   isAbortError,
+  isCustomReasoning,
   isNonNullable,
   isParsableJson,
+  isProviderReference,
   isUrlSupported,
   jsonSchema,
   lazySchema,
   loadApiKey,
   loadOptionalSetting,
   loadSetting,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
   mediaTypeToExtension,
   normalizeHeaders,
   parseJSON,
@@ -2834,8 +2875,10 @@ var import_stream2 = require("eventsource-parser/stream");
   readResponseWithSizeLimit,
   removeUndefinedEntries,
   resolve,
+  resolveProviderReference,
   safeParseJSON,
   safeValidateTypes,
+  serializeModelOptions,
   stripFileExtension,
   tool,
   validateDownloadUrl,
@@ -2843,5 +2886,5 @@ var import_stream2 = require("eventsource-parser/stream");
   withUserAgentSuffix,
   withoutTrailingSlash,
   zodSchema
-});
+};
 //# sourceMappingURL=index.js.map