@ai-sdk/provider-utils 2.2.7 → 3.0.0-alpha.1

package/dist/index.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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-
@@ -30,10 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  asSchema: () => asSchema,
   asValidator: () => asValidator,
   combineHeaders: () => combineHeaders,
   convertAsyncIteratorToReadableStream: () => convertAsyncIteratorToReadableStream,
   convertBase64ToUint8Array: () => convertBase64ToUint8Array,
+  convertToBase64: () => convertToBase64,
   convertUint8ArrayToBase64: () => convertUint8ArrayToBase64,
   createBinaryResponseHandler: () => createBinaryResponseHandler,
   createEventSourceParserStream: () => createEventSourceParserStream,
@@ -50,11 +53,14 @@ __export(src_exports, {
   getFromApi: () => getFromApi,
   isAbortError: () => isAbortError,
   isParsableJson: () => isParsableJson,
+  isUrlSupported: () => isUrlSupported,
   isValidator: () => isValidator,
+  jsonSchema: () => jsonSchema,
   loadApiKey: () => loadApiKey,
   loadOptionalSetting: () => loadOptionalSetting,
   loadSetting: () => loadSetting,
   parseJSON: () => parseJSON,
+  parseJsonEventStream: () => parseJsonEventStream,
   parseProviderOptions: () => parseProviderOptions,
   postFormDataToApi: () => postFormDataToApi,
   postJsonToApi: () => postJsonToApi,
@@ -63,11 +69,12 @@ __export(src_exports, {
   resolve: () => resolve,
   safeParseJSON: () => safeParseJSON,
   safeValidateTypes: () => safeValidateTypes,
+  standardSchemaValidator: () => standardSchemaValidator,
   validateTypes: () => validateTypes,
   validator: () => validator,
   validatorSymbol: () => validatorSymbol,
   withoutTrailingSlash: () => withoutTrailingSlash,
-  zodValidator: () => zodValidator
+  zodSchema: () => zodSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -198,7 +205,7 @@ function splitLines(buffer, chunk) {
     } else if (char === "\r") {
       lines.push(currentLine);
       currentLine = "";
-      if (chunk[i + 1] === "\n") {
+      if (chunk[i] === "\n") {
         i++;
       }
     } else {
@@ -219,14 +226,20 @@ function extractResponseHeaders(response) {
 
 // src/generate-id.ts
 var import_provider = require("@ai-sdk/provider");
-var import_non_secure = require("nanoid/non-secure");
 var createIdGenerator = ({
   prefix,
-  size: defaultSize = 16,
+  size = 16,
   alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   separator = "-"
 } = {}) => {
-  const generator = (0, import_non_secure.customAlphabet)(alphabet, defaultSize);
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0; i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
   if (prefix == null) {
     return generator;
   }
@@ -236,7 +249,7 @@ var createIdGenerator = ({
       message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
     });
   }
-  return (size) => `${prefix}${separator}${generator(size)}`;
+  return () => `${prefix}${separator}${generator()}`;
 };
 var generateId = createIdGenerator();
 
@@ -350,6 +363,20 @@ var getFromApi = async ({
   }
 };
 
+// src/is-url-supported.ts
+function isUrlSupported({
+  mediaType,
+  url,
+  supportedUrls
+}) {
+  url = url.toLowerCase();
+  mediaType = mediaType.toLowerCase();
+  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));
+}
+
 // src/load-api-key.ts
 var import_provider3 = require("@ai-sdk/provider");
 function loadApiKey({
@@ -439,13 +466,58 @@ function loadSetting({
 }
 
 // src/parse-json.ts
-var import_provider6 = require("@ai-sdk/provider");
-var import_secure_json_parse = __toESM(require("secure-json-parse"));
+var import_provider7 = require("@ai-sdk/provider");
+
+// src/secure-json-parse.ts
+var suspectProtoRx = /"__proto__"\s*:/;
+var suspectConstructorRx = /"constructor"\s*:/;
+function _parse(text) {
+  const obj = JSON.parse(text);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+    return obj;
+  }
+  return filter(obj);
+}
+function filter(obj) {
+  let next = [obj];
+  while (next.length) {
+    const nodes = next;
+    next = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+function secureJsonParse(text) {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  try {
+    return _parse(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
 
 // src/validate-types.ts
-var import_provider5 = require("@ai-sdk/provider");
+var import_provider6 = require("@ai-sdk/provider");
 
 // src/validator.ts
+var import_provider5 = require("@ai-sdk/provider");
 var validatorSymbol = Symbol.for("vercel.ai.validator");
 function validator(validate) {
   return { [validatorSymbol]: true, validate };
@@ -454,99 +526,124 @@ function isValidator(value) {
   return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
 }
 function asValidator(value) {
-  return isValidator(value) ? value : zodValidator(value);
+  return isValidator(value) ? value : standardSchemaValidator(value);
 }
-function zodValidator(zodSchema) {
-  return validator((value) => {
-    const result = zodSchema.safeParse(value);
-    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+function standardSchemaValidator(standardSchema) {
+  return validator(async (value) => {
+    const result = await standardSchema["~standard"].validate(value);
+    return result.issues == null ? { success: true, value: result.value } : {
+      success: false,
+      error: new import_provider5.TypeValidationError({
+        value,
+        cause: result.issues
+      })
+    };
   });
 }
 
 // src/validate-types.ts
-function validateTypes({
+async function validateTypes({
   value,
-  schema: inputSchema
+  schema
 }) {
-  const result = safeValidateTypes({ value, schema: inputSchema });
+  const result = await safeValidateTypes({ value, schema });
   if (!result.success) {
-    throw import_provider5.TypeValidationError.wrap({ value, cause: result.error });
+    throw import_provider6.TypeValidationError.wrap({ value, cause: result.error });
   }
   return result.value;
 }
-function safeValidateTypes({
+async function safeValidateTypes({
   value,
   schema
 }) {
   const validator2 = asValidator(schema);
   try {
     if (validator2.validate == null) {
-      return { success: true, value };
+      return { success: true, value, rawValue: value };
     }
-    const result = validator2.validate(value);
+    const result = await validator2.validate(value);
     if (result.success) {
-      return result;
+      return { success: true, value: result.value, rawValue: value };
     }
     return {
       success: false,
-      error: import_provider5.TypeValidationError.wrap({ value, cause: result.error })
+      error: import_provider6.TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: import_provider5.TypeValidationError.wrap({ value, cause: error })
+      error: import_provider6.TypeValidationError.wrap({ value, cause: error }),
+      rawValue: value
     };
   }
 }
 
 // src/parse-json.ts
-function parseJSON({
+async function parseJSON({
   text,
   schema
 }) {
   try {
-    const value = import_secure_json_parse.default.parse(text);
+    const value = secureJsonParse(text);
     if (schema == null) {
       return value;
     }
     return validateTypes({ value, schema });
   } catch (error) {
-    if (import_provider6.JSONParseError.isInstance(error) || import_provider6.TypeValidationError.isInstance(error)) {
+    if (import_provider7.JSONParseError.isInstance(error) || import_provider7.TypeValidationError.isInstance(error)) {
       throw error;
     }
-    throw new import_provider6.JSONParseError({ text, cause: error });
+    throw new import_provider7.JSONParseError({ text, cause: error });
   }
 }
-function safeParseJSON({
+async function safeParseJSON({
   text,
   schema
 }) {
   try {
-    const value = import_secure_json_parse.default.parse(text);
+    const value = secureJsonParse(text);
     if (schema == null) {
       return { success: true, value, rawValue: value };
     }
-    const validationResult = safeValidateTypes({ value, schema });
-    return validationResult.success ? { ...validationResult, rawValue: value } : validationResult;
+    return await safeValidateTypes({ value, schema });
   } catch (error) {
     return {
       success: false,
-      error: import_provider6.JSONParseError.isInstance(error) ? error : new import_provider6.JSONParseError({ text, cause: error })
+      error: import_provider7.JSONParseError.isInstance(error) ? error : new import_provider7.JSONParseError({ text, cause: error }),
+      rawValue: void 0
     };
   }
 }
 function isParsableJson(input) {
   try {
-    import_secure_json_parse.default.parse(input);
+    secureJsonParse(input);
     return true;
   } catch (e) {
     return false;
   }
 }
 
+// src/parse-json-event-stream.ts
+function parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data }, controller) {
+        if (data === "[DONE]") {
+          return;
+        }
+        controller.enqueue(await safeParseJSON({ text: data, schema }));
+      }
+    })
+  );
+}
+
 // src/parse-provider-options.ts
-var import_provider7 = require("@ai-sdk/provider");
-function parseProviderOptions({
+var import_provider8 = require("@ai-sdk/provider");
+async function parseProviderOptions({
   provider,
   providerOptions,
   schema
@@ -554,12 +651,12 @@ function parseProviderOptions({
   if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
     return void 0;
   }
-  const parsedProviderOptions = safeValidateTypes({
+  const parsedProviderOptions = await safeValidateTypes({
     value: providerOptions[provider],
     schema
   });
   if (!parsedProviderOptions.success) {
-    throw new import_provider7.InvalidArgumentError({
+    throw new import_provider8.InvalidArgumentError({
       argument: "providerOptions",
       message: `invalid ${provider} provider options`,
       cause: parsedProviderOptions.error
@@ -569,7 +666,7 @@ function parseProviderOptions({
 }
 
 // src/post-to-api.ts
-var import_provider8 = require("@ai-sdk/provider");
+var import_provider9 = require("@ai-sdk/provider");
 var getOriginalFetch2 = () => globalThis.fetch;
 var postJsonToApi = async ({
   url,
@@ -640,10 +737,10 @@ var postToApi = async ({
           requestBodyValues: body.values
         });
       } catch (error) {
-        if (isAbortError(error) || import_provider8.APICallError.isInstance(error)) {
+        if (isAbortError(error) || import_provider9.APICallError.isInstance(error)) {
           throw error;
         }
-        throw new import_provider8.APICallError({
+        throw new import_provider9.APICallError({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -662,11 +759,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || import_provider8.APICallError.isInstance(error)) {
+        if (isAbortError(error) || import_provider9.APICallError.isInstance(error)) {
           throw error;
         }
       }
-      throw new import_provider8.APICallError({
+      throw new import_provider9.APICallError({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -682,7 +779,7 @@ var postToApi = async ({
     if (error instanceof TypeError && error.message === "fetch failed") {
       const cause = error.cause;
       if (cause != null) {
-        throw new import_provider8.APICallError({
+        throw new import_provider9.APICallError({
           message: `Cannot connect to API: ${cause.message}`,
           cause,
           url,
@@ -705,7 +802,7 @@ async function resolve(value) {
 }
 
 // src/response-handler.ts
-var import_provider9 = require("@ai-sdk/provider");
+var import_provider10 = require("@ai-sdk/provider");
 var createJsonErrorResponseHandler = ({
   errorSchema,
   errorToMessage,
@@ -716,7 +813,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new import_provider9.APICallError({
+      value: new import_provider10.APICallError({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -728,13 +825,13 @@ var createJsonErrorResponseHandler = ({
     };
   }
   try {
-    const parsedError = parseJSON({
+    const parsedError = await parseJSON({
       text: responseBody,
       schema: errorSchema
     });
     return {
       responseHeaders,
-      value: new import_provider9.APICallError({
+      value: new import_provider10.APICallError({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -748,7 +845,7 @@ var createJsonErrorResponseHandler = ({
   } catch (parseError) {
     return {
       responseHeaders,
-      value: new import_provider9.APICallError({
+      value: new import_provider10.APICallError({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -763,41 +860,30 @@ var createJsonErrorResponseHandler = ({
 var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider9.EmptyResponseBodyError({});
+    throw new import_provider10.EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
-    value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream()).pipeThrough(
-      new TransformStream({
-        transform({ data }, controller) {
-          if (data === "[DONE]") {
-            return;
-          }
-          controller.enqueue(
-            safeParseJSON({
-              text: data,
-              schema: chunkSchema
-            })
-          );
-        }
-      })
-    )
+    value: parseJsonEventStream({
+      stream: response.body,
+      schema: chunkSchema
+    })
   };
 };
 var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider9.EmptyResponseBodyError({});
+    throw new import_provider10.EmptyResponseBodyError({});
   }
   let buffer = "";
   return {
     responseHeaders,
     value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(
       new TransformStream({
-        transform(chunkText, controller) {
+        async transform(chunkText, controller) {
           if (chunkText.endsWith("\n")) {
             controller.enqueue(
-              safeParseJSON({
+              await safeParseJSON({
                 text: buffer + chunkText,
                 schema: chunkSchema
               })
@@ -813,13 +899,13 @@ var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
 };
 var createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
   const responseBody = await response.text();
-  const parsedResult = safeParseJSON({
+  const parsedResult = await safeParseJSON({
     text: responseBody,
     schema: responseSchema
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new import_provider9.APICallError({
+    throw new import_provider10.APICallError({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -838,7 +924,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
 var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (!response.body) {
-    throw new import_provider9.APICallError({
+    throw new import_provider10.APICallError({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -854,7 +940,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
       value: new Uint8Array(buffer)
     };
   } catch (error) {
-    throw new import_provider9.APICallError({
+    throw new import_provider10.APICallError({
       message: "Failed to read response as array buffer",
       url,
       requestBodyValues,
@@ -870,7 +956,7 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   const responseBody = await response.text();
   return {
     responseHeaders,
-    value: new import_provider9.APICallError({
+    value: new import_provider10.APICallError({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -881,6 +967,50 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   };
 };
 
+// src/zod-schema.ts
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
+function zodSchema(zodSchema2, options) {
+  var _a;
+  const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
+  return jsonSchema(
+    (0, import_zod_to_json_schema.default)(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none",
+      target: "jsonSchema7"
+      // note: openai mode breaks various gemini conversions
+    }),
+    {
+      validate: (value) => {
+        const result = zodSchema2.safeParse(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+
+// src/schema.ts
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return schema == null ? jsonSchema({
+    properties: {},
+    additionalProperties: false
+  }) : isSchema(schema) ? schema : zodSchema(schema);
+}
+
 // src/uint8-utils.ts
 var { btoa, atob } = globalThis;
 function convertBase64ToUint8Array(base64String) {
@@ -895,17 +1025,25 @@ function convertUint8ArrayToBase64(array) {
   }
   return btoa(latin1string);
 }
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
 
 // src/without-trailing-slash.ts
 function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
+
+// src/index.ts
+__reExport(src_exports, require("@standard-schema/spec"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  asSchema,
   asValidator,
   combineHeaders,
   convertAsyncIteratorToReadableStream,
   convertBase64ToUint8Array,
+  convertToBase64,
   convertUint8ArrayToBase64,
   createBinaryResponseHandler,
   createEventSourceParserStream,
@@ -922,11 +1060,14 @@ function withoutTrailingSlash(url) {
   getFromApi,
   isAbortError,
   isParsableJson,
+  isUrlSupported,
   isValidator,
+  jsonSchema,
   loadApiKey,
   loadOptionalSetting,
   loadSetting,
   parseJSON,
+  parseJsonEventStream,
   parseProviderOptions,
   postFormDataToApi,
   postJsonToApi,
@@ -935,10 +1076,12 @@ function withoutTrailingSlash(url) {
   resolve,
   safeParseJSON,
   safeValidateTypes,
+  standardSchemaValidator,
   validateTypes,
   validator,
   validatorSymbol,
   withoutTrailingSlash,
-  zodValidator
+  zodSchema,
+  ...require("@standard-schema/spec")
 });
 //# sourceMappingURL=index.js.map