2850 lines
82 KiB
JavaScript
2850 lines
82 KiB
JavaScript
"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(
|
|
(combinedHeaders, currentHeaders) => ({
|
|
...combinedHeaders,
|
|
...currentHeaders != null ? currentHeaders : {}
|
|
}),
|
|
{}
|
|
);
|
|
}
|
|
|
|
// src/convert-async-iterator-to-readable-stream.ts
|
|
function convertAsyncIteratorToReadableStream(iterator) {
|
|
let cancelled = false;
|
|
return new ReadableStream({
|
|
/**
|
|
* Called when the consumer wants to pull more data from the stream.
|
|
*
|
|
* @param {ReadableStreamDefaultController<T>} controller - The controller to enqueue data into the stream.
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async pull(controller) {
|
|
if (cancelled) return;
|
|
try {
|
|
const { value, done } = await iterator.next();
|
|
if (done) {
|
|
controller.close();
|
|
} else {
|
|
controller.enqueue(value);
|
|
}
|
|
} catch (error) {
|
|
controller.error(error);
|
|
}
|
|
},
|
|
/**
|
|
* Called when the consumer cancels the stream.
|
|
*/
|
|
async cancel(reason) {
|
|
cancelled = true;
|
|
if (iterator.return) {
|
|
try {
|
|
await iterator.return(reason);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// src/create-tool-name-mapping.ts
|
|
function createToolNameMapping({
|
|
tools = [],
|
|
providerToolNames,
|
|
resolveProviderToolName
|
|
}) {
|
|
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;
|
|
}
|
|
customToolNameToProviderToolName[tool2.name] = providerToolName;
|
|
providerToolNameToCustomToolName[providerToolName] = tool2.name;
|
|
}
|
|
}
|
|
return {
|
|
toProviderToolName: (customToolName) => {
|
|
var _a3;
|
|
return (_a3 = customToolNameToProviderToolName[customToolName]) != null ? _a3 : customToolName;
|
|
},
|
|
toCustomToolName: (providerToolName) => {
|
|
var _a3;
|
|
return (_a3 = providerToolNameToCustomToolName[providerToolName]) != null ? _a3 : providerToolName;
|
|
}
|
|
};
|
|
}
|
|
|
|
// src/delay.ts
|
|
async function delay(delayInMs, options) {
|
|
if (delayInMs == null) {
|
|
return Promise.resolve();
|
|
}
|
|
const signal = options == null ? void 0 : options.abortSignal;
|
|
return new Promise((resolve2, reject) => {
|
|
if (signal == null ? void 0 : signal.aborted) {
|
|
reject(createAbortError());
|
|
return;
|
|
}
|
|
const timeoutId = setTimeout(() => {
|
|
cleanup();
|
|
resolve2();
|
|
}, delayInMs);
|
|
const cleanup = () => {
|
|
clearTimeout(timeoutId);
|
|
signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
|
|
};
|
|
const onAbort = () => {
|
|
cleanup();
|
|
reject(createAbortError());
|
|
};
|
|
signal == null ? void 0 : signal.addEventListener("abort", onAbort);
|
|
});
|
|
}
|
|
function createAbortError() {
|
|
return new DOMException("Delay was aborted", "AbortError");
|
|
}
|
|
|
|
// src/delayed-promise.ts
|
|
var DelayedPromise = class {
|
|
constructor() {
|
|
this.status = { type: "pending" };
|
|
this._resolve = void 0;
|
|
this._reject = void 0;
|
|
}
|
|
get promise() {
|
|
if (this._promise) {
|
|
return this._promise;
|
|
}
|
|
this._promise = new Promise((resolve2, reject) => {
|
|
if (this.status.type === "resolved") {
|
|
resolve2(this.status.value);
|
|
} else if (this.status.type === "rejected") {
|
|
reject(this.status.error);
|
|
}
|
|
this._resolve = resolve2;
|
|
this._reject = reject;
|
|
});
|
|
return this._promise;
|
|
}
|
|
resolve(value) {
|
|
var _a2;
|
|
this.status = { type: "resolved", value };
|
|
if (this._promise) {
|
|
(_a2 = this._resolve) == null ? void 0 : _a2.call(this, value);
|
|
}
|
|
}
|
|
reject(error) {
|
|
var _a2;
|
|
this.status = { type: "rejected", error };
|
|
if (this._promise) {
|
|
(_a2 = this._reject) == null ? void 0 : _a2.call(this, error);
|
|
}
|
|
}
|
|
isResolved() {
|
|
return this.status.type === "resolved";
|
|
}
|
|
isRejected() {
|
|
return this.status.type === "rejected";
|
|
}
|
|
isPending() {
|
|
return this.status.type === "pending";
|
|
}
|
|
};
|
|
|
|
// 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");
|
|
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) {
|
|
constructor({
|
|
url,
|
|
statusCode,
|
|
statusText,
|
|
cause,
|
|
message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
|
|
}) {
|
|
super({ name, message, cause });
|
|
this[_a] = true;
|
|
this.url = url;
|
|
this.statusCode = statusCode;
|
|
this.statusText = statusText;
|
|
}
|
|
static isInstance(error) {
|
|
return import_provider.AISDKError.hasMarker(error, marker);
|
|
}
|
|
};
|
|
|
|
// src/read-response-with-size-limit.ts
|
|
var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
|
|
async function readResponseWithSizeLimit({
|
|
response,
|
|
url,
|
|
maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
|
|
}) {
|
|
const contentLength = response.headers.get("content-length");
|
|
if (contentLength != null) {
|
|
const length = parseInt(contentLength, 10);
|
|
if (!isNaN(length) && length > maxBytes) {
|
|
throw new DownloadError({
|
|
url,
|
|
message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
|
|
});
|
|
}
|
|
}
|
|
const body = response.body;
|
|
if (body == null) {
|
|
return new Uint8Array(0);
|
|
}
|
|
const reader = body.getReader();
|
|
const chunks = [];
|
|
let totalBytes = 0;
|
|
try {
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) {
|
|
break;
|
|
}
|
|
totalBytes += value.length;
|
|
if (totalBytes > maxBytes) {
|
|
throw new DownloadError({
|
|
url,
|
|
message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
|
|
});
|
|
}
|
|
chunks.push(value);
|
|
}
|
|
} finally {
|
|
try {
|
|
await reader.cancel();
|
|
} finally {
|
|
reader.releaseLock();
|
|
}
|
|
}
|
|
const result = new Uint8Array(totalBytes);
|
|
let offset = 0;
|
|
for (const chunk of chunks) {
|
|
result.set(chunk, offset);
|
|
offset += chunk.length;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// src/validate-download-url.ts
|
|
function validateDownloadUrl(url) {
|
|
let parsed;
|
|
try {
|
|
parsed = new URL(url);
|
|
} catch (e) {
|
|
throw new DownloadError({
|
|
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, https, or data, got ${parsed.protocol}`
|
|
});
|
|
}
|
|
const hostname = parsed.hostname;
|
|
if (!hostname) {
|
|
throw new DownloadError({
|
|
url,
|
|
message: `URL must have a hostname`
|
|
});
|
|
}
|
|
if (hostname === "localhost" || hostname.endsWith(".local") || hostname.endsWith(".localhost")) {
|
|
throw new DownloadError({
|
|
url,
|
|
message: `URL with hostname ${hostname} is not allowed`
|
|
});
|
|
}
|
|
if (hostname.startsWith("[") && hostname.endsWith("]")) {
|
|
const ipv6 = hostname.slice(1, -1);
|
|
if (isPrivateIPv6(ipv6)) {
|
|
throw new DownloadError({
|
|
url,
|
|
message: `URL with IPv6 address ${hostname} is not allowed`
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
if (isIPv4(hostname)) {
|
|
if (isPrivateIPv4(hostname)) {
|
|
throw new DownloadError({
|
|
url,
|
|
message: `URL with IP address ${hostname} is not allowed`
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
function isIPv4(hostname) {
|
|
const parts = hostname.split(".");
|
|
if (parts.length !== 4) return false;
|
|
return parts.every((part) => {
|
|
const num = Number(part);
|
|
return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
|
|
});
|
|
}
|
|
function isPrivateIPv4(ip) {
|
|
const parts = ip.split(".").map(Number);
|
|
const [a, b] = parts;
|
|
if (a === 0) return true;
|
|
if (a === 10) return true;
|
|
if (a === 127) return true;
|
|
if (a === 169 && b === 254) return true;
|
|
if (a === 172 && b >= 16 && b <= 31) return true;
|
|
if (a === 192 && b === 168) return true;
|
|
return false;
|
|
}
|
|
function isPrivateIPv6(ip) {
|
|
const normalized = ip.toLowerCase();
|
|
if (normalized === "::1") return true;
|
|
if (normalized === "::") return true;
|
|
if (normalized.startsWith("::ffff:")) {
|
|
const mappedPart = normalized.slice(7);
|
|
if (isIPv4(mappedPart)) {
|
|
return isPrivateIPv4(mappedPart);
|
|
}
|
|
const hexParts = mappedPart.split(":");
|
|
if (hexParts.length === 2) {
|
|
const high = parseInt(hexParts[0], 16);
|
|
const low = parseInt(hexParts[1], 16);
|
|
if (!isNaN(high) && !isNaN(low)) {
|
|
const a = high >> 8 & 255;
|
|
const b = high & 255;
|
|
const c = low >> 8 & 255;
|
|
const d = low & 255;
|
|
return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
|
|
}
|
|
}
|
|
}
|
|
if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
|
|
if (normalized.startsWith("fe80")) return true;
|
|
return false;
|
|
}
|
|
|
|
// src/download-blob.ts
|
|
async function downloadBlob(url, options) {
|
|
var _a2, _b2;
|
|
validateDownloadUrl(url);
|
|
try {
|
|
const response = await fetch(url, {
|
|
signal: options == null ? void 0 : options.abortSignal
|
|
});
|
|
if (response.redirected) {
|
|
validateDownloadUrl(response.url);
|
|
}
|
|
if (!response.ok) {
|
|
throw new DownloadError({
|
|
url,
|
|
statusCode: response.status,
|
|
statusText: response.statusText
|
|
});
|
|
}
|
|
const data = await readResponseWithSizeLimit({
|
|
response,
|
|
url,
|
|
maxBytes: (_a2 = options == null ? void 0 : options.maxBytes) != null ? _a2 : DEFAULT_MAX_DOWNLOAD_SIZE
|
|
});
|
|
const contentType = (_b2 = response.headers.get("content-type")) != null ? _b2 : void 0;
|
|
return new Blob([data], contentType ? { type: contentType } : void 0);
|
|
} catch (error) {
|
|
if (DownloadError.isInstance(error)) {
|
|
throw error;
|
|
}
|
|
throw new DownloadError({ url, cause: error });
|
|
}
|
|
}
|
|
|
|
// src/generate-id.ts
|
|
var import_provider2 = require("@ai-sdk/provider");
|
|
var createIdGenerator = ({
|
|
prefix,
|
|
size = 16,
|
|
alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
|
|
separator = "-"
|
|
} = {}) => {
|
|
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;
|
|
}
|
|
if (alphabet.includes(separator)) {
|
|
throw new import_provider2.InvalidArgumentError({
|
|
argument: "separator",
|
|
message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
|
|
});
|
|
}
|
|
return () => `${prefix}${separator}${generator()}`;
|
|
};
|
|
var generateId = createIdGenerator();
|
|
|
|
// src/get-error-message.ts
|
|
function getErrorMessage(error) {
|
|
if (error == null) {
|
|
return "unknown error";
|
|
}
|
|
if (typeof error === "string") {
|
|
return error;
|
|
}
|
|
if (error instanceof Error) {
|
|
return error.message;
|
|
}
|
|
return JSON.stringify(error);
|
|
}
|
|
|
|
// src/get-from-api.ts
|
|
var import_provider4 = require("@ai-sdk/provider");
|
|
|
|
// src/handle-fetch-error.ts
|
|
var import_provider3 = require("@ai-sdk/provider");
|
|
|
|
// src/is-abort-error.ts
|
|
function isAbortError(error) {
|
|
return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
|
|
error.name === "TimeoutError");
|
|
}
|
|
|
|
// src/handle-fetch-error.ts
|
|
var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
|
|
var BUN_ERROR_CODES = [
|
|
"ConnectionRefused",
|
|
"ConnectionClosed",
|
|
"FailedToOpenSocket",
|
|
"ECONNRESET",
|
|
"ECONNREFUSED",
|
|
"ETIMEDOUT",
|
|
"EPIPE"
|
|
];
|
|
function isBunNetworkError(error) {
|
|
if (!(error instanceof Error)) {
|
|
return false;
|
|
}
|
|
const code = error.code;
|
|
if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function handleFetchError({
|
|
error,
|
|
url,
|
|
requestBodyValues
|
|
}) {
|
|
if (isAbortError(error)) {
|
|
return error;
|
|
}
|
|
if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
|
|
const cause = error.cause;
|
|
if (cause != null) {
|
|
return new import_provider3.APICallError({
|
|
message: `Cannot connect to API: ${cause.message}`,
|
|
cause,
|
|
url,
|
|
requestBodyValues,
|
|
isRetryable: true
|
|
// retry when network error
|
|
});
|
|
}
|
|
}
|
|
if (isBunNetworkError(error)) {
|
|
return new import_provider3.APICallError({
|
|
message: `Cannot connect to API: ${error.message}`,
|
|
cause: error,
|
|
url,
|
|
requestBodyValues,
|
|
isRetryable: true
|
|
});
|
|
}
|
|
return error;
|
|
}
|
|
|
|
// src/get-runtime-environment-user-agent.ts
|
|
function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
|
|
var _a2, _b2, _c;
|
|
if (globalThisAny.window) {
|
|
return `runtime/browser`;
|
|
}
|
|
if ((_a2 = globalThisAny.navigator) == null ? void 0 : _a2.userAgent) {
|
|
return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
|
|
}
|
|
if ((_c = (_b2 = globalThisAny.process) == null ? void 0 : _b2.versions) == null ? void 0 : _c.node) {
|
|
return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
|
|
}
|
|
if (globalThisAny.EdgeRuntime) {
|
|
return `runtime/vercel-edge`;
|
|
}
|
|
return "runtime/unknown";
|
|
}
|
|
|
|
// src/normalize-headers.ts
|
|
function normalizeHeaders(headers) {
|
|
if (headers == null) {
|
|
return {};
|
|
}
|
|
const normalized = {};
|
|
if (headers instanceof Headers) {
|
|
headers.forEach((value, key) => {
|
|
normalized[key.toLowerCase()] = value;
|
|
});
|
|
} else {
|
|
if (!Array.isArray(headers)) {
|
|
headers = Object.entries(headers);
|
|
}
|
|
for (const [key, value] of headers) {
|
|
if (value != null) {
|
|
normalized[key.toLowerCase()] = value;
|
|
}
|
|
}
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
// src/with-user-agent-suffix.ts
|
|
function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
|
|
const normalizedHeaders = new Headers(normalizeHeaders(headers));
|
|
const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
|
|
normalizedHeaders.set(
|
|
"user-agent",
|
|
[currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
|
|
);
|
|
return Object.fromEntries(normalizedHeaders.entries());
|
|
}
|
|
|
|
// src/version.ts
|
|
var VERSION = true ? "4.0.23" : "0.0.0-test";
|
|
|
|
// src/get-from-api.ts
|
|
var getOriginalFetch = () => globalThis.fetch;
|
|
var getFromApi = async ({
|
|
url,
|
|
headers = {},
|
|
successfulResponseHandler,
|
|
failedResponseHandler,
|
|
abortSignal,
|
|
fetch: fetch2 = getOriginalFetch()
|
|
}) => {
|
|
try {
|
|
const response = await fetch2(url, {
|
|
method: "GET",
|
|
headers: withUserAgentSuffix(
|
|
headers,
|
|
`ai-sdk/provider-utils/${VERSION}`,
|
|
getRuntimeEnvironmentUserAgent()
|
|
),
|
|
signal: abortSignal
|
|
});
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
if (!response.ok) {
|
|
let errorInformation;
|
|
try {
|
|
errorInformation = await failedResponseHandler({
|
|
response,
|
|
url,
|
|
requestBodyValues: {}
|
|
});
|
|
} catch (error) {
|
|
if (isAbortError(error) || import_provider4.APICallError.isInstance(error)) {
|
|
throw error;
|
|
}
|
|
throw new import_provider4.APICallError({
|
|
message: "Failed to process error response",
|
|
cause: error,
|
|
statusCode: response.status,
|
|
url,
|
|
responseHeaders,
|
|
requestBodyValues: {}
|
|
});
|
|
}
|
|
throw errorInformation.value;
|
|
}
|
|
try {
|
|
return await successfulResponseHandler({
|
|
response,
|
|
url,
|
|
requestBodyValues: {}
|
|
});
|
|
} catch (error) {
|
|
if (error instanceof Error) {
|
|
if (isAbortError(error) || import_provider4.APICallError.isInstance(error)) {
|
|
throw error;
|
|
}
|
|
}
|
|
throw new import_provider4.APICallError({
|
|
message: "Failed to process successful response",
|
|
cause: error,
|
|
statusCode: response.status,
|
|
url,
|
|
responseHeaders,
|
|
requestBodyValues: {}
|
|
});
|
|
}
|
|
} catch (error) {
|
|
throw handleFetchError({ error, url, requestBodyValues: {} });
|
|
}
|
|
};
|
|
|
|
// src/inject-json-instruction.ts
|
|
var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
|
|
var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
|
|
var DEFAULT_GENERIC_SUFFIX = "You MUST answer with JSON.";
|
|
function injectJsonInstruction({
|
|
prompt,
|
|
schema,
|
|
schemaPrefix = schema != null ? DEFAULT_SCHEMA_PREFIX : void 0,
|
|
schemaSuffix = schema != null ? DEFAULT_SCHEMA_SUFFIX : DEFAULT_GENERIC_SUFFIX
|
|
}) {
|
|
return [
|
|
prompt != null && prompt.length > 0 ? prompt : void 0,
|
|
prompt != null && prompt.length > 0 ? "" : void 0,
|
|
// add a newline if prompt is not null
|
|
schemaPrefix,
|
|
schema != null ? JSON.stringify(schema) : void 0,
|
|
schemaSuffix
|
|
].filter((line) => line != null).join("\n");
|
|
}
|
|
function injectJsonInstructionIntoMessages({
|
|
messages,
|
|
schema,
|
|
schemaPrefix,
|
|
schemaSuffix
|
|
}) {
|
|
var _a2, _b2;
|
|
const systemMessage = ((_a2 = messages[0]) == null ? void 0 : _a2.role) === "system" ? { ...messages[0] } : { role: "system", content: "" };
|
|
systemMessage.content = injectJsonInstruction({
|
|
prompt: systemMessage.content,
|
|
schema,
|
|
schemaPrefix,
|
|
schemaSuffix
|
|
});
|
|
return [
|
|
systemMessage,
|
|
...((_b2 = messages[0]) == null ? void 0 : _b2.role) === "system" ? messages.slice(1) : messages
|
|
];
|
|
}
|
|
|
|
// src/is-non-nullable.ts
|
|
function isNonNullable(value) {
|
|
return value != null;
|
|
}
|
|
|
|
// 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_provider5 = require("@ai-sdk/provider");
|
|
function loadApiKey({
|
|
apiKey,
|
|
environmentVariableName,
|
|
apiKeyParameterName = "apiKey",
|
|
description
|
|
}) {
|
|
if (typeof apiKey === "string") {
|
|
return apiKey;
|
|
}
|
|
if (apiKey != null) {
|
|
throw new import_provider5.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 are not supported in this environment.`
|
|
});
|
|
}
|
|
apiKey = process.env[environmentVariableName];
|
|
if (apiKey == null) {
|
|
throw new import_provider5.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({
|
|
message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
|
|
});
|
|
}
|
|
return apiKey;
|
|
}
|
|
|
|
// src/load-optional-setting.ts
|
|
function loadOptionalSetting({
|
|
settingValue,
|
|
environmentVariableName
|
|
}) {
|
|
if (typeof settingValue === "string") {
|
|
return settingValue;
|
|
}
|
|
if (settingValue != null || typeof process === "undefined") {
|
|
return void 0;
|
|
}
|
|
settingValue = process.env[environmentVariableName];
|
|
if (settingValue == null || typeof settingValue !== "string") {
|
|
return void 0;
|
|
}
|
|
return settingValue;
|
|
}
|
|
|
|
// src/load-setting.ts
|
|
var import_provider6 = require("@ai-sdk/provider");
|
|
function loadSetting({
|
|
settingValue,
|
|
environmentVariableName,
|
|
settingName,
|
|
description
|
|
}) {
|
|
if (typeof settingValue === "string") {
|
|
return settingValue;
|
|
}
|
|
if (settingValue != null) {
|
|
throw new import_provider6.LoadSettingError({
|
|
message: `${description} setting must be a string.`
|
|
});
|
|
}
|
|
if (typeof process === "undefined") {
|
|
throw new import_provider6.LoadSettingError({
|
|
message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables are not supported in this environment.`
|
|
});
|
|
}
|
|
settingValue = process.env[environmentVariableName];
|
|
if (settingValue == null) {
|
|
throw new import_provider6.LoadSettingError({
|
|
message: `${description} setting is missing. Pass it using the '${settingName}' parameter or the ${environmentVariableName} environment variable.`
|
|
});
|
|
}
|
|
if (typeof settingValue !== "string") {
|
|
throw new import_provider6.LoadSettingError({
|
|
message: `${description} setting must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
|
|
});
|
|
}
|
|
return settingValue;
|
|
}
|
|
|
|
// src/media-type-to-extension.ts
|
|
function mediaTypeToExtension(mediaType) {
|
|
var _a2;
|
|
const [_type, subtype = ""] = mediaType.toLowerCase().split("/");
|
|
return (_a2 = {
|
|
mpeg: "mp3",
|
|
"x-wav": "wav",
|
|
opus: "ogg",
|
|
mp4: "m4a",
|
|
"x-m4a": "m4a"
|
|
}[subtype]) != null ? _a2 : subtype;
|
|
}
|
|
|
|
// src/parse-json.ts
|
|
var import_provider9 = require("@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*:/;
|
|
var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\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") && node.constructor !== null && typeof node.constructor === "object" && 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;
|
|
try {
|
|
Error.stackTraceLimit = 0;
|
|
} catch (e) {
|
|
return _parse(text);
|
|
}
|
|
try {
|
|
return _parse(text);
|
|
} finally {
|
|
Error.stackTraceLimit = stackTraceLimit;
|
|
}
|
|
}
|
|
|
|
// src/validate-types.ts
|
|
var import_provider8 = require("@ai-sdk/provider");
|
|
|
|
// src/schema.ts
|
|
var import_provider7 = require("@ai-sdk/provider");
|
|
var z4 = __toESM(require("zod/v4"));
|
|
|
|
// src/add-additional-properties-to-json-schema.ts
|
|
function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
|
|
if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
|
|
jsonSchema2.additionalProperties = false;
|
|
const { properties } = jsonSchema2;
|
|
if (properties != null) {
|
|
for (const key of Object.keys(properties)) {
|
|
properties[key] = visit(properties[key]);
|
|
}
|
|
}
|
|
}
|
|
if (jsonSchema2.items != null) {
|
|
jsonSchema2.items = Array.isArray(jsonSchema2.items) ? jsonSchema2.items.map(visit) : visit(jsonSchema2.items);
|
|
}
|
|
if (jsonSchema2.anyOf != null) {
|
|
jsonSchema2.anyOf = jsonSchema2.anyOf.map(visit);
|
|
}
|
|
if (jsonSchema2.allOf != null) {
|
|
jsonSchema2.allOf = jsonSchema2.allOf.map(visit);
|
|
}
|
|
if (jsonSchema2.oneOf != null) {
|
|
jsonSchema2.oneOf = jsonSchema2.oneOf.map(visit);
|
|
}
|
|
const { definitions } = jsonSchema2;
|
|
if (definitions != null) {
|
|
for (const key of Object.keys(definitions)) {
|
|
definitions[key] = visit(definitions[key]);
|
|
}
|
|
}
|
|
return jsonSchema2;
|
|
}
|
|
function visit(def) {
|
|
if (typeof def === "boolean") return def;
|
|
return addAdditionalPropertiesToJsonSchema(def);
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/options.ts
|
|
var ignoreOverride = /* @__PURE__ */ Symbol(
|
|
"Let zodToJsonSchema decide on which parser to use"
|
|
);
|
|
var defaultOptions = {
|
|
name: void 0,
|
|
$refStrategy: "root",
|
|
basePath: ["#"],
|
|
effectStrategy: "input",
|
|
pipeStrategy: "all",
|
|
dateStrategy: "format:date-time",
|
|
mapStrategy: "entries",
|
|
removeAdditionalStrategy: "passthrough",
|
|
allowedAdditionalProperties: true,
|
|
rejectedAdditionalProperties: false,
|
|
definitionPath: "definitions",
|
|
strictUnions: false,
|
|
definitions: {},
|
|
errorMessages: false,
|
|
patternStrategy: "escape",
|
|
applyRegexFlags: false,
|
|
emailStrategy: "format:email",
|
|
base64Strategy: "contentEncoding:base64",
|
|
nameStrategy: "ref"
|
|
};
|
|
var getDefaultOptions = (options) => typeof options === "string" ? {
|
|
...defaultOptions,
|
|
name: options
|
|
} : {
|
|
...defaultOptions,
|
|
...options
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/select-parser.ts
|
|
var import_v33 = require("zod/v3");
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/any.ts
|
|
function parseAnyDef() {
|
|
return {};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/array.ts
|
|
var import_v3 = require("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) {
|
|
res.items = parseDef(def.type._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items"]
|
|
});
|
|
}
|
|
if (def.minLength) {
|
|
res.minItems = def.minLength.value;
|
|
}
|
|
if (def.maxLength) {
|
|
res.maxItems = def.maxLength.value;
|
|
}
|
|
if (def.exactLength) {
|
|
res.minItems = def.exactLength.value;
|
|
res.maxItems = def.exactLength.value;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/bigint.ts
|
|
function parseBigintDef(def) {
|
|
const res = {
|
|
type: "integer",
|
|
format: "int64"
|
|
};
|
|
if (!def.checks) return res;
|
|
for (const check of def.checks) {
|
|
switch (check.kind) {
|
|
case "min":
|
|
if (check.inclusive) {
|
|
res.minimum = check.value;
|
|
} else {
|
|
res.exclusiveMinimum = check.value;
|
|
}
|
|
break;
|
|
case "max":
|
|
if (check.inclusive) {
|
|
res.maximum = check.value;
|
|
} else {
|
|
res.exclusiveMaximum = check.value;
|
|
}
|
|
break;
|
|
case "multipleOf":
|
|
res.multipleOf = check.value;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/boolean.ts
|
|
function parseBooleanDef() {
|
|
return { type: "boolean" };
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/branded.ts
|
|
function parseBrandedDef(_def, refs) {
|
|
return parseDef(_def.type._def, refs);
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/catch.ts
|
|
var parseCatchDef = (def, refs) => {
|
|
return parseDef(def.innerType._def, refs);
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/date.ts
|
|
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))
|
|
};
|
|
}
|
|
switch (strategy) {
|
|
case "string":
|
|
case "format:date-time":
|
|
return {
|
|
type: "string",
|
|
format: "date-time"
|
|
};
|
|
case "format:date":
|
|
return {
|
|
type: "string",
|
|
format: "date"
|
|
};
|
|
case "integer":
|
|
return integerDateParser(def);
|
|
}
|
|
}
|
|
var integerDateParser = (def) => {
|
|
const res = {
|
|
type: "integer",
|
|
format: "unix-time"
|
|
};
|
|
for (const check of def.checks) {
|
|
switch (check.kind) {
|
|
case "min":
|
|
res.minimum = check.value;
|
|
break;
|
|
case "max":
|
|
res.maximum = check.value;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/default.ts
|
|
function parseDefaultDef(_def, refs) {
|
|
return {
|
|
...parseDef(_def.innerType._def, refs),
|
|
default: _def.defaultValue()
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/effects.ts
|
|
function parseEffectsDef(_def, refs) {
|
|
return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/enum.ts
|
|
function parseEnumDef(def) {
|
|
return {
|
|
type: "string",
|
|
enum: Array.from(def.values)
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/intersection.ts
|
|
var isJsonSchema7AllOfType = (type) => {
|
|
if ("type" in type && type.type === "string") return false;
|
|
return "allOf" in type;
|
|
};
|
|
function parseIntersectionDef(def, refs) {
|
|
const allOf = [
|
|
parseDef(def.left._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", "0"]
|
|
}),
|
|
parseDef(def.right._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", "1"]
|
|
})
|
|
].filter((x) => !!x);
|
|
const mergedAllOf = [];
|
|
allOf.forEach((schema) => {
|
|
if (isJsonSchema7AllOfType(schema)) {
|
|
mergedAllOf.push(...schema.allOf);
|
|
} else {
|
|
let nestedSchema = schema;
|
|
if ("additionalProperties" in schema && schema.additionalProperties === false) {
|
|
const { additionalProperties, ...rest } = schema;
|
|
nestedSchema = rest;
|
|
}
|
|
mergedAllOf.push(nestedSchema);
|
|
}
|
|
});
|
|
return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/literal.ts
|
|
function parseLiteralDef(def) {
|
|
const parsedType = typeof def.value;
|
|
if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
|
|
return {
|
|
type: Array.isArray(def.value) ? "array" : "object"
|
|
};
|
|
}
|
|
return {
|
|
type: parsedType === "bigint" ? "integer" : parsedType,
|
|
const: def.value
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/record.ts
|
|
var import_v32 = require("zod/v3");
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/string.ts
|
|
var emojiRegex = void 0;
|
|
var zodPatterns = {
|
|
/**
|
|
* `c` was changed to `[cC]` to replicate /i flag
|
|
*/
|
|
cuid: /^[cC][^\s-]{8,}$/,
|
|
cuid2: /^[0-9a-z]+$/,
|
|
ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
|
|
/**
|
|
* `a-z` was added to replicate /i flag
|
|
*/
|
|
email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
|
|
/**
|
|
* Constructed a valid Unicode RegExp
|
|
*
|
|
* Lazily instantiate since this type of regex isn't supported
|
|
* in all envs (e.g. React Native).
|
|
*
|
|
* See:
|
|
* https://github.com/colinhacks/zod/issues/2433
|
|
* Fix in Zod:
|
|
* https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
|
|
*/
|
|
emoji: () => {
|
|
if (emojiRegex === void 0) {
|
|
emojiRegex = RegExp(
|
|
"^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
|
|
"u"
|
|
);
|
|
}
|
|
return emojiRegex;
|
|
},
|
|
/**
|
|
* Unused
|
|
*/
|
|
uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
|
|
/**
|
|
* Unused
|
|
*/
|
|
ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
|
|
ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
|
|
/**
|
|
* Unused
|
|
*/
|
|
ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
|
|
ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
|
|
base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
|
|
base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
|
|
nanoid: /^[a-zA-Z0-9_-]{21}$/,
|
|
jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
|
|
};
|
|
function parseStringDef(def, refs) {
|
|
const res = {
|
|
type: "string"
|
|
};
|
|
if (def.checks) {
|
|
for (const check of def.checks) {
|
|
switch (check.kind) {
|
|
case "min":
|
|
res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
|
|
break;
|
|
case "max":
|
|
res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
|
|
break;
|
|
case "email":
|
|
switch (refs.emailStrategy) {
|
|
case "format:email":
|
|
addFormat(res, "email", check.message, refs);
|
|
break;
|
|
case "format:idn-email":
|
|
addFormat(res, "idn-email", check.message, refs);
|
|
break;
|
|
case "pattern:zod":
|
|
addPattern(res, zodPatterns.email, check.message, refs);
|
|
break;
|
|
}
|
|
break;
|
|
case "url":
|
|
addFormat(res, "uri", check.message, refs);
|
|
break;
|
|
case "uuid":
|
|
addFormat(res, "uuid", check.message, refs);
|
|
break;
|
|
case "regex":
|
|
addPattern(res, check.regex, check.message, refs);
|
|
break;
|
|
case "cuid":
|
|
addPattern(res, zodPatterns.cuid, check.message, refs);
|
|
break;
|
|
case "cuid2":
|
|
addPattern(res, zodPatterns.cuid2, check.message, refs);
|
|
break;
|
|
case "startsWith":
|
|
addPattern(
|
|
res,
|
|
RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`),
|
|
check.message,
|
|
refs
|
|
);
|
|
break;
|
|
case "endsWith":
|
|
addPattern(
|
|
res,
|
|
RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`),
|
|
check.message,
|
|
refs
|
|
);
|
|
break;
|
|
case "datetime":
|
|
addFormat(res, "date-time", check.message, refs);
|
|
break;
|
|
case "date":
|
|
addFormat(res, "date", check.message, refs);
|
|
break;
|
|
case "time":
|
|
addFormat(res, "time", check.message, refs);
|
|
break;
|
|
case "duration":
|
|
addFormat(res, "duration", check.message, refs);
|
|
break;
|
|
case "length":
|
|
res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
|
|
res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
|
|
break;
|
|
case "includes": {
|
|
addPattern(
|
|
res,
|
|
RegExp(escapeLiteralCheckValue(check.value, refs)),
|
|
check.message,
|
|
refs
|
|
);
|
|
break;
|
|
}
|
|
case "ip": {
|
|
if (check.version !== "v6") {
|
|
addFormat(res, "ipv4", check.message, refs);
|
|
}
|
|
if (check.version !== "v4") {
|
|
addFormat(res, "ipv6", check.message, refs);
|
|
}
|
|
break;
|
|
}
|
|
case "base64url":
|
|
addPattern(res, zodPatterns.base64url, check.message, refs);
|
|
break;
|
|
case "jwt":
|
|
addPattern(res, zodPatterns.jwt, check.message, refs);
|
|
break;
|
|
case "cidr": {
|
|
if (check.version !== "v6") {
|
|
addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
|
|
}
|
|
if (check.version !== "v4") {
|
|
addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
|
|
}
|
|
break;
|
|
}
|
|
case "emoji":
|
|
addPattern(res, zodPatterns.emoji(), check.message, refs);
|
|
break;
|
|
case "ulid": {
|
|
addPattern(res, zodPatterns.ulid, check.message, refs);
|
|
break;
|
|
}
|
|
case "base64": {
|
|
switch (refs.base64Strategy) {
|
|
case "format:binary": {
|
|
addFormat(res, "binary", check.message, refs);
|
|
break;
|
|
}
|
|
case "contentEncoding:base64": {
|
|
res.contentEncoding = "base64";
|
|
break;
|
|
}
|
|
case "pattern:zod": {
|
|
addPattern(res, zodPatterns.base64, check.message, refs);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "nanoid": {
|
|
addPattern(res, zodPatterns.nanoid, check.message, refs);
|
|
}
|
|
case "toLowerCase":
|
|
case "toUpperCase":
|
|
case "trim":
|
|
break;
|
|
default:
|
|
/* @__PURE__ */ ((_) => {
|
|
})(check);
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function escapeLiteralCheckValue(literal, refs) {
|
|
return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
|
|
}
|
|
var ALPHA_NUMERIC = new Set(
|
|
"ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
|
|
);
|
|
function escapeNonAlphaNumeric(source) {
|
|
let result = "";
|
|
for (let i = 0; i < source.length; i++) {
|
|
if (!ALPHA_NUMERIC.has(source[i])) {
|
|
result += "\\";
|
|
}
|
|
result += source[i];
|
|
}
|
|
return result;
|
|
}
|
|
function addFormat(schema, value, message, refs) {
|
|
var _a2;
|
|
if (schema.format || ((_a2 = schema.anyOf) == null ? void 0 : _a2.some((x) => x.format))) {
|
|
if (!schema.anyOf) {
|
|
schema.anyOf = [];
|
|
}
|
|
if (schema.format) {
|
|
schema.anyOf.push({
|
|
format: schema.format
|
|
});
|
|
delete schema.format;
|
|
}
|
|
schema.anyOf.push({
|
|
format: value,
|
|
...message && refs.errorMessages && { errorMessage: { format: message } }
|
|
});
|
|
} else {
|
|
schema.format = value;
|
|
}
|
|
}
|
|
function addPattern(schema, regex, message, refs) {
|
|
var _a2;
|
|
if (schema.pattern || ((_a2 = schema.allOf) == null ? void 0 : _a2.some((x) => x.pattern))) {
|
|
if (!schema.allOf) {
|
|
schema.allOf = [];
|
|
}
|
|
if (schema.pattern) {
|
|
schema.allOf.push({
|
|
pattern: schema.pattern
|
|
});
|
|
delete schema.pattern;
|
|
}
|
|
schema.allOf.push({
|
|
pattern: stringifyRegExpWithFlags(regex, refs),
|
|
...message && refs.errorMessages && { errorMessage: { pattern: message } }
|
|
});
|
|
} else {
|
|
schema.pattern = stringifyRegExpWithFlags(regex, refs);
|
|
}
|
|
}
|
|
function stringifyRegExpWithFlags(regex, refs) {
|
|
var _a2;
|
|
if (!refs.applyRegexFlags || !regex.flags) {
|
|
return regex.source;
|
|
}
|
|
const flags = {
|
|
i: regex.flags.includes("i"),
|
|
// Case-insensitive
|
|
m: regex.flags.includes("m"),
|
|
// `^` and `$` matches adjacent to newline characters
|
|
s: regex.flags.includes("s")
|
|
// `.` matches newlines
|
|
};
|
|
const source = flags.i ? regex.source.toLowerCase() : regex.source;
|
|
let pattern = "";
|
|
let isEscaped = false;
|
|
let inCharGroup = false;
|
|
let inCharRange = false;
|
|
for (let i = 0; i < source.length; i++) {
|
|
if (isEscaped) {
|
|
pattern += source[i];
|
|
isEscaped = false;
|
|
continue;
|
|
}
|
|
if (flags.i) {
|
|
if (inCharGroup) {
|
|
if (source[i].match(/[a-z]/)) {
|
|
if (inCharRange) {
|
|
pattern += source[i];
|
|
pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
|
|
inCharRange = false;
|
|
} else if (source[i + 1] === "-" && ((_a2 = source[i + 2]) == null ? void 0 : _a2.match(/[a-z]/))) {
|
|
pattern += source[i];
|
|
inCharRange = true;
|
|
} else {
|
|
pattern += `${source[i]}${source[i].toUpperCase()}`;
|
|
}
|
|
continue;
|
|
}
|
|
} else if (source[i].match(/[a-z]/)) {
|
|
pattern += `[${source[i]}${source[i].toUpperCase()}]`;
|
|
continue;
|
|
}
|
|
}
|
|
if (flags.m) {
|
|
if (source[i] === "^") {
|
|
pattern += `(^|(?<=[\r
|
|
]))`;
|
|
continue;
|
|
} else if (source[i] === "$") {
|
|
pattern += `($|(?=[\r
|
|
]))`;
|
|
continue;
|
|
}
|
|
}
|
|
if (flags.s && source[i] === ".") {
|
|
pattern += inCharGroup ? `${source[i]}\r
|
|
` : `[${source[i]}\r
|
|
]`;
|
|
continue;
|
|
}
|
|
pattern += source[i];
|
|
if (source[i] === "\\") {
|
|
isEscaped = true;
|
|
} else if (inCharGroup && source[i] === "]") {
|
|
inCharGroup = false;
|
|
} else if (!inCharGroup && source[i] === "[") {
|
|
inCharGroup = true;
|
|
}
|
|
}
|
|
try {
|
|
new RegExp(pattern);
|
|
} catch (e) {
|
|
console.warn(
|
|
`Could not convert regex pattern at ${refs.currentPath.join(
|
|
"/"
|
|
)} to a flag-independent form! Falling back to the flag-ignorant source`
|
|
);
|
|
return regex.source;
|
|
}
|
|
return pattern;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/record.ts
|
|
function parseRecordDef(def, refs) {
|
|
var _a2, _b2, _c, _d, _e, _f;
|
|
const schema = {
|
|
type: "object",
|
|
additionalProperties: (_a2 = parseDef(def.valueType._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);
|
|
return {
|
|
...schema,
|
|
propertyNames: keyType
|
|
};
|
|
} else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v32.ZodFirstPartyTypeKind.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(
|
|
def.keyType._def,
|
|
refs
|
|
);
|
|
return {
|
|
...schema,
|
|
propertyNames: keyType
|
|
};
|
|
}
|
|
return schema;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/map.ts
|
|
function parseMapDef(def, refs) {
|
|
if (refs.mapStrategy === "record") {
|
|
return parseRecordDef(def, refs);
|
|
}
|
|
const keys = parseDef(def.keyType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", "items", "0"]
|
|
}) || parseAnyDef();
|
|
const values = parseDef(def.valueType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", "items", "1"]
|
|
}) || parseAnyDef();
|
|
return {
|
|
type: "array",
|
|
maxItems: 125,
|
|
items: {
|
|
type: "array",
|
|
items: [keys, values],
|
|
minItems: 2,
|
|
maxItems: 2
|
|
}
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/native-enum.ts
|
|
function parseNativeEnumDef(def) {
|
|
const object = def.values;
|
|
const actualKeys = Object.keys(def.values).filter((key) => {
|
|
return typeof object[object[key]] !== "number";
|
|
});
|
|
const actualValues = actualKeys.map((key) => object[key]);
|
|
const parsedTypes = Array.from(
|
|
new Set(actualValues.map((values) => typeof values))
|
|
);
|
|
return {
|
|
type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
|
|
enum: actualValues
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/never.ts
|
|
function parseNeverDef() {
|
|
return { not: parseAnyDef() };
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/null.ts
|
|
function parseNullDef() {
|
|
return {
|
|
type: "null"
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/union.ts
|
|
var primitiveMappings = {
|
|
ZodString: "string",
|
|
ZodNumber: "number",
|
|
ZodBigInt: "integer",
|
|
ZodBoolean: "boolean",
|
|
ZodNull: "null"
|
|
};
|
|
function parseUnionDef(def, refs) {
|
|
const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
|
|
if (options.every(
|
|
(x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
|
|
)) {
|
|
const types = options.reduce((types2, x) => {
|
|
const type = primitiveMappings[x._def.typeName];
|
|
return type && !types2.includes(type) ? [...types2, type] : types2;
|
|
}, []);
|
|
return {
|
|
type: types.length > 1 ? types : types[0]
|
|
};
|
|
} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
|
|
const types = options.reduce(
|
|
(acc, x) => {
|
|
const type = typeof x._def.value;
|
|
switch (type) {
|
|
case "string":
|
|
case "number":
|
|
case "boolean":
|
|
return [...acc, type];
|
|
case "bigint":
|
|
return [...acc, "integer"];
|
|
case "object":
|
|
if (x._def.value === null) return [...acc, "null"];
|
|
case "symbol":
|
|
case "undefined":
|
|
case "function":
|
|
default:
|
|
return acc;
|
|
}
|
|
},
|
|
[]
|
|
);
|
|
if (types.length === options.length) {
|
|
const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
|
|
return {
|
|
type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
|
|
enum: options.reduce(
|
|
(acc, x) => {
|
|
return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
|
|
},
|
|
[]
|
|
)
|
|
};
|
|
}
|
|
} else if (options.every((x) => x._def.typeName === "ZodEnum")) {
|
|
return {
|
|
type: "string",
|
|
enum: options.reduce(
|
|
(acc, x) => [
|
|
...acc,
|
|
...x._def.values.filter((x2) => !acc.includes(x2))
|
|
],
|
|
[]
|
|
)
|
|
};
|
|
}
|
|
return asAnyOf(def, refs);
|
|
}
|
|
var asAnyOf = (def, refs) => {
|
|
const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
|
|
(x, i) => parseDef(x._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "anyOf", `${i}`]
|
|
})
|
|
).filter(
|
|
(x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
|
|
);
|
|
return anyOf.length ? { anyOf } : void 0;
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/nullable.ts
|
|
function parseNullableDef(def, refs) {
|
|
if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
|
|
def.innerType._def.typeName
|
|
) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
|
|
return {
|
|
type: [
|
|
primitiveMappings[def.innerType._def.typeName],
|
|
"null"
|
|
]
|
|
};
|
|
}
|
|
const base = parseDef(def.innerType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "anyOf", "0"]
|
|
});
|
|
return base && { anyOf: [base, { type: "null" }] };
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/number.ts
|
|
function parseNumberDef(def) {
|
|
const res = {
|
|
type: "number"
|
|
};
|
|
if (!def.checks) return res;
|
|
for (const check of def.checks) {
|
|
switch (check.kind) {
|
|
case "int":
|
|
res.type = "integer";
|
|
break;
|
|
case "min":
|
|
if (check.inclusive) {
|
|
res.minimum = check.value;
|
|
} else {
|
|
res.exclusiveMinimum = check.value;
|
|
}
|
|
break;
|
|
case "max":
|
|
if (check.inclusive) {
|
|
res.maximum = check.value;
|
|
} else {
|
|
res.exclusiveMaximum = check.value;
|
|
}
|
|
break;
|
|
case "multipleOf":
|
|
res.multipleOf = check.value;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/object.ts
|
|
function parseObjectDef(def, refs) {
|
|
const result = {
|
|
type: "object",
|
|
properties: {}
|
|
};
|
|
const required = [];
|
|
const shape = def.shape();
|
|
for (const propName in shape) {
|
|
let propDef = shape[propName];
|
|
if (propDef === void 0 || propDef._def === void 0) {
|
|
continue;
|
|
}
|
|
const propOptional = safeIsOptional(propDef);
|
|
const parsedDef = parseDef(propDef._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "properties", propName],
|
|
propertyPath: [...refs.currentPath, "properties", propName]
|
|
});
|
|
if (parsedDef === void 0) {
|
|
continue;
|
|
}
|
|
result.properties[propName] = parsedDef;
|
|
if (!propOptional) {
|
|
required.push(propName);
|
|
}
|
|
}
|
|
if (required.length) {
|
|
result.required = required;
|
|
}
|
|
const additionalProperties = decideAdditionalProperties(def, refs);
|
|
if (additionalProperties !== void 0) {
|
|
result.additionalProperties = additionalProperties;
|
|
}
|
|
return result;
|
|
}
|
|
function decideAdditionalProperties(def, refs) {
|
|
if (def.catchall._def.typeName !== "ZodNever") {
|
|
return parseDef(def.catchall._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "additionalProperties"]
|
|
});
|
|
}
|
|
switch (def.unknownKeys) {
|
|
case "passthrough":
|
|
return refs.allowedAdditionalProperties;
|
|
case "strict":
|
|
return refs.rejectedAdditionalProperties;
|
|
case "strip":
|
|
return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
|
|
}
|
|
}
|
|
function safeIsOptional(schema) {
|
|
try {
|
|
return schema.isOptional();
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/optional.ts
|
|
var parseOptionalDef = (def, refs) => {
|
|
var _a2;
|
|
if (refs.currentPath.toString() === ((_a2 = refs.propertyPath) == null ? void 0 : _a2.toString())) {
|
|
return parseDef(def.innerType._def, refs);
|
|
}
|
|
const innerSchema = parseDef(def.innerType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "anyOf", "1"]
|
|
});
|
|
return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/pipeline.ts
|
|
var parsePipelineDef = (def, refs) => {
|
|
if (refs.pipeStrategy === "input") {
|
|
return parseDef(def.in._def, refs);
|
|
} else if (refs.pipeStrategy === "output") {
|
|
return parseDef(def.out._def, refs);
|
|
}
|
|
const a = parseDef(def.in._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", "0"]
|
|
});
|
|
const b = parseDef(def.out._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
|
|
});
|
|
return {
|
|
allOf: [a, b].filter((x) => x !== void 0)
|
|
};
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/promise.ts
|
|
function parsePromiseDef(def, refs) {
|
|
return parseDef(def.type._def, refs);
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/set.ts
|
|
function parseSetDef(def, refs) {
|
|
const items = parseDef(def.valueType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items"]
|
|
});
|
|
const schema = {
|
|
type: "array",
|
|
uniqueItems: true,
|
|
items
|
|
};
|
|
if (def.minSize) {
|
|
schema.minItems = def.minSize.value;
|
|
}
|
|
if (def.maxSize) {
|
|
schema.maxItems = def.maxSize.value;
|
|
}
|
|
return schema;
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/tuple.ts
|
|
function parseTupleDef(def, refs) {
|
|
if (def.rest) {
|
|
return {
|
|
type: "array",
|
|
minItems: def.items.length,
|
|
items: def.items.map(
|
|
(x, i) => parseDef(x._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", `${i}`]
|
|
})
|
|
).reduce(
|
|
(acc, x) => x === void 0 ? acc : [...acc, x],
|
|
[]
|
|
),
|
|
additionalItems: parseDef(def.rest._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "additionalItems"]
|
|
})
|
|
};
|
|
} else {
|
|
return {
|
|
type: "array",
|
|
minItems: def.items.length,
|
|
maxItems: def.items.length,
|
|
items: def.items.map(
|
|
(x, i) => parseDef(x._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", `${i}`]
|
|
})
|
|
).reduce(
|
|
(acc, x) => x === void 0 ? acc : [...acc, x],
|
|
[]
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/undefined.ts
|
|
function parseUndefinedDef() {
|
|
return {
|
|
not: parseAnyDef()
|
|
};
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/unknown.ts
|
|
function parseUnknownDef() {
|
|
return parseAnyDef();
|
|
}
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parsers/readonly.ts
|
|
var parseReadonlyDef = (def, refs) => {
|
|
return parseDef(def.innerType._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:
|
|
return parseStringDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodNumber:
|
|
return parseNumberDef(def);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodObject:
|
|
return parseObjectDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodBigInt:
|
|
return parseBigintDef(def);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodBoolean:
|
|
return parseBooleanDef();
|
|
case import_v33.ZodFirstPartyTypeKind.ZodDate:
|
|
return parseDateDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodUndefined:
|
|
return parseUndefinedDef();
|
|
case import_v33.ZodFirstPartyTypeKind.ZodNull:
|
|
return parseNullDef();
|
|
case import_v33.ZodFirstPartyTypeKind.ZodArray:
|
|
return parseArrayDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodUnion:
|
|
case import_v33.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
|
|
return parseUnionDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodIntersection:
|
|
return parseIntersectionDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodTuple:
|
|
return parseTupleDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodRecord:
|
|
return parseRecordDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodLiteral:
|
|
return parseLiteralDef(def);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodEnum:
|
|
return parseEnumDef(def);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodNativeEnum:
|
|
return parseNativeEnumDef(def);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodNullable:
|
|
return parseNullableDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodOptional:
|
|
return parseOptionalDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodMap:
|
|
return parseMapDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodSet:
|
|
return parseSetDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodLazy:
|
|
return () => def.getter()._def;
|
|
case import_v33.ZodFirstPartyTypeKind.ZodPromise:
|
|
return parsePromiseDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodNaN:
|
|
case import_v33.ZodFirstPartyTypeKind.ZodNever:
|
|
return parseNeverDef();
|
|
case import_v33.ZodFirstPartyTypeKind.ZodEffects:
|
|
return parseEffectsDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodAny:
|
|
return parseAnyDef();
|
|
case import_v33.ZodFirstPartyTypeKind.ZodUnknown:
|
|
return parseUnknownDef();
|
|
case import_v33.ZodFirstPartyTypeKind.ZodDefault:
|
|
return parseDefaultDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodBranded:
|
|
return parseBrandedDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodReadonly:
|
|
return parseReadonlyDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodCatch:
|
|
return parseCatchDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodPipeline:
|
|
return parsePipelineDef(def, refs);
|
|
case import_v33.ZodFirstPartyTypeKind.ZodFunction:
|
|
case import_v33.ZodFirstPartyTypeKind.ZodVoid:
|
|
case import_v33.ZodFirstPartyTypeKind.ZodSymbol:
|
|
return void 0;
|
|
default:
|
|
return /* @__PURE__ */ ((_) => void 0)(typeName);
|
|
}
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/get-relative-path.ts
|
|
var getRelativePath = (pathA, pathB) => {
|
|
let i = 0;
|
|
for (; i < pathA.length && i < pathB.length; i++) {
|
|
if (pathA[i] !== pathB[i]) break;
|
|
}
|
|
return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/parse-def.ts
|
|
function parseDef(def, refs, forceResolution = false) {
|
|
var _a2;
|
|
const seenItem = refs.seen.get(def);
|
|
if (refs.override) {
|
|
const overrideResult = (_a2 = refs.override) == null ? void 0 : _a2.call(
|
|
refs,
|
|
def,
|
|
refs,
|
|
seenItem,
|
|
forceResolution
|
|
);
|
|
if (overrideResult !== ignoreOverride) {
|
|
return overrideResult;
|
|
}
|
|
}
|
|
if (seenItem && !forceResolution) {
|
|
const seenSchema = get$ref(seenItem, refs);
|
|
if (seenSchema !== void 0) {
|
|
return seenSchema;
|
|
}
|
|
}
|
|
const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
|
|
refs.seen.set(def, newItem);
|
|
const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
|
|
const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
|
|
if (jsonSchema2) {
|
|
addMeta(def, refs, jsonSchema2);
|
|
}
|
|
if (refs.postProcess) {
|
|
const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
|
|
newItem.jsonSchema = jsonSchema2;
|
|
return postProcessResult;
|
|
}
|
|
newItem.jsonSchema = jsonSchema2;
|
|
return jsonSchema2;
|
|
}
|
|
var get$ref = (item, refs) => {
|
|
switch (refs.$refStrategy) {
|
|
case "root":
|
|
return { $ref: item.path.join("/") };
|
|
case "relative":
|
|
return { $ref: getRelativePath(refs.currentPath, item.path) };
|
|
case "none":
|
|
case "seen": {
|
|
if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
|
|
console.warn(
|
|
`Recursive reference detected at ${refs.currentPath.join(
|
|
"/"
|
|
)}! Defaulting to any`
|
|
);
|
|
return parseAnyDef();
|
|
}
|
|
return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
|
|
}
|
|
}
|
|
};
|
|
var addMeta = (def, refs, jsonSchema2) => {
|
|
if (def.description) {
|
|
jsonSchema2.description = def.description;
|
|
}
|
|
return jsonSchema2;
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/refs.ts
|
|
var getRefs = (options) => {
|
|
const _options = getDefaultOptions(options);
|
|
const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
|
|
return {
|
|
..._options,
|
|
currentPath,
|
|
propertyPath: void 0,
|
|
seen: new Map(
|
|
Object.entries(_options.definitions).map(([name2, def]) => [
|
|
def._def,
|
|
{
|
|
def: def._def,
|
|
path: [..._options.basePath, _options.definitionPath, name2],
|
|
// Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
|
|
jsonSchema: void 0
|
|
}
|
|
])
|
|
)
|
|
};
|
|
};
|
|
|
|
// src/to-json-schema/zod3-to-json-schema/zod3-to-json-schema.ts
|
|
var zod3ToJsonSchema = (schema, options) => {
|
|
var _a2;
|
|
const refs = getRefs(options);
|
|
let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
|
|
(acc, [name3, schema2]) => {
|
|
var _a3;
|
|
return {
|
|
...acc,
|
|
[name3]: (_a3 = parseDef(
|
|
schema2._def,
|
|
{
|
|
...refs,
|
|
currentPath: [...refs.basePath, refs.definitionPath, name3]
|
|
},
|
|
true
|
|
)) != null ? _a3 : parseAnyDef()
|
|
};
|
|
},
|
|
{}
|
|
) : void 0;
|
|
const name2 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
|
|
const main = (_a2 = parseDef(
|
|
schema._def,
|
|
name2 === void 0 ? refs : {
|
|
...refs,
|
|
currentPath: [...refs.basePath, refs.definitionPath, name2]
|
|
},
|
|
false
|
|
)) != null ? _a2 : parseAnyDef();
|
|
const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
|
|
if (title !== void 0) {
|
|
main.title = title;
|
|
}
|
|
const combined = name2 === void 0 ? definitions ? {
|
|
...main,
|
|
[refs.definitionPath]: definitions
|
|
} : main : {
|
|
$ref: [
|
|
...refs.$refStrategy === "relative" ? [] : refs.basePath,
|
|
refs.definitionPath,
|
|
name2
|
|
].join("/"),
|
|
[refs.definitionPath]: {
|
|
...definitions,
|
|
[name2]: main
|
|
}
|
|
};
|
|
combined.$schema = "http://json-schema.org/draft-07/schema#";
|
|
return combined;
|
|
};
|
|
|
|
// src/schema.ts
|
|
var schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
|
|
function lazySchema(createSchema) {
|
|
let schema;
|
|
return () => {
|
|
if (schema == null) {
|
|
schema = createSchema();
|
|
}
|
|
return schema;
|
|
};
|
|
}
|
|
function jsonSchema(jsonSchema2, {
|
|
validate
|
|
} = {}) {
|
|
return {
|
|
[schemaSymbol]: true,
|
|
_type: void 0,
|
|
// should never be used directly
|
|
get jsonSchema() {
|
|
if (typeof jsonSchema2 === "function") {
|
|
jsonSchema2 = jsonSchema2();
|
|
}
|
|
return 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 : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
|
|
}
|
|
function standardSchema(standardSchema2) {
|
|
return jsonSchema(
|
|
() => addAdditionalPropertiesToJsonSchema(
|
|
standardSchema2["~standard"].jsonSchema.input({
|
|
target: "draft-07"
|
|
})
|
|
),
|
|
{
|
|
validate: async (value) => {
|
|
const result = await standardSchema2["~standard"].validate(value);
|
|
return "value" in result ? { success: true, value: result.value } : {
|
|
success: false,
|
|
error: new import_provider7.TypeValidationError({
|
|
value,
|
|
cause: result.issues
|
|
})
|
|
};
|
|
}
|
|
}
|
|
);
|
|
}
|
|
function zod3Schema(zodSchema2, options) {
|
|
var _a2;
|
|
const useReferences = (_a2 = options == null ? void 0 : options.useReferences) != null ? _a2 : false;
|
|
return jsonSchema(
|
|
// defer json schema creation to avoid unnecessary computation when only validation is needed
|
|
() => zod3ToJsonSchema(zodSchema2, {
|
|
$refStrategy: useReferences ? "root" : "none"
|
|
}),
|
|
{
|
|
validate: async (value) => {
|
|
const result = await zodSchema2.safeParseAsync(value);
|
|
return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
|
|
}
|
|
}
|
|
);
|
|
}
|
|
function zod4Schema(zodSchema2, options) {
|
|
var _a2;
|
|
const useReferences = (_a2 = options == null ? void 0 : options.useReferences) != null ? _a2 : false;
|
|
return jsonSchema(
|
|
// defer json schema creation to avoid unnecessary computation when only validation is needed
|
|
() => addAdditionalPropertiesToJsonSchema(
|
|
z4.toJSONSchema(zodSchema2, {
|
|
target: "draft-7",
|
|
io: "input",
|
|
reused: useReferences ? "ref" : "inline"
|
|
})
|
|
),
|
|
{
|
|
validate: async (value) => {
|
|
const result = await z4.safeParseAsync(zodSchema2, value);
|
|
return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
|
|
}
|
|
}
|
|
);
|
|
}
|
|
function isZod4Schema(zodSchema2) {
|
|
return "_zod" in zodSchema2;
|
|
}
|
|
function zodSchema(zodSchema2, options) {
|
|
if (isZod4Schema(zodSchema2)) {
|
|
return zod4Schema(zodSchema2, options);
|
|
} else {
|
|
return zod3Schema(zodSchema2, options);
|
|
}
|
|
}
|
|
|
|
// src/validate-types.ts
|
|
async function validateTypes({
|
|
value,
|
|
schema,
|
|
context
|
|
}) {
|
|
const result = await safeValidateTypes({ value, schema, context });
|
|
if (!result.success) {
|
|
throw import_provider8.TypeValidationError.wrap({ value, cause: result.error, context });
|
|
}
|
|
return result.value;
|
|
}
|
|
async function safeValidateTypes({
|
|
value,
|
|
schema,
|
|
context
|
|
}) {
|
|
const actualSchema = asSchema(schema);
|
|
try {
|
|
if (actualSchema.validate == null) {
|
|
return { success: true, value, rawValue: value };
|
|
}
|
|
const result = await actualSchema.validate(value);
|
|
if (result.success) {
|
|
return { success: true, value: result.value, rawValue: value };
|
|
}
|
|
return {
|
|
success: false,
|
|
error: import_provider8.TypeValidationError.wrap({ value, cause: result.error, context }),
|
|
rawValue: value
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: import_provider8.TypeValidationError.wrap({ value, cause: error, context }),
|
|
rawValue: value
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/parse-json.ts
|
|
async function parseJSON({
|
|
text,
|
|
schema
|
|
}) {
|
|
try {
|
|
const value = secureJsonParse(text);
|
|
if (schema == null) {
|
|
return value;
|
|
}
|
|
return validateTypes({ value, schema });
|
|
} catch (error) {
|
|
if (import_provider9.JSONParseError.isInstance(error) || import_provider9.TypeValidationError.isInstance(error)) {
|
|
throw error;
|
|
}
|
|
throw new import_provider9.JSONParseError({ text, cause: error });
|
|
}
|
|
}
|
|
async function safeParseJSON({
|
|
text,
|
|
schema
|
|
}) {
|
|
try {
|
|
const value = secureJsonParse(text);
|
|
if (schema == null) {
|
|
return { success: true, value, rawValue: value };
|
|
}
|
|
return await safeValidateTypes({ value, schema });
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: import_provider9.JSONParseError.isInstance(error) ? error : new import_provider9.JSONParseError({ text, cause: error }),
|
|
rawValue: void 0
|
|
};
|
|
}
|
|
}
|
|
function isParsableJson(input) {
|
|
try {
|
|
secureJsonParse(input);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// src/parse-json-event-stream.ts
|
|
var import_stream = require("eventsource-parser/stream");
|
|
function parseJsonEventStream({
|
|
stream,
|
|
schema
|
|
}) {
|
|
return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new import_stream.EventSourceParserStream()).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_provider10 = require("@ai-sdk/provider");
|
|
async function parseProviderOptions({
|
|
provider,
|
|
providerOptions,
|
|
schema
|
|
}) {
|
|
if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
|
|
return void 0;
|
|
}
|
|
const parsedProviderOptions = await safeValidateTypes({
|
|
value: providerOptions[provider],
|
|
schema
|
|
});
|
|
if (!parsedProviderOptions.success) {
|
|
throw new import_provider10.InvalidArgumentError({
|
|
argument: "providerOptions",
|
|
message: `invalid ${provider} provider options`,
|
|
cause: parsedProviderOptions.error
|
|
});
|
|
}
|
|
return parsedProviderOptions.value;
|
|
}
|
|
|
|
// src/post-to-api.ts
|
|
var import_provider11 = require("@ai-sdk/provider");
|
|
var getOriginalFetch2 = () => globalThis.fetch;
|
|
var postJsonToApi = async ({
|
|
url,
|
|
headers,
|
|
body,
|
|
failedResponseHandler,
|
|
successfulResponseHandler,
|
|
abortSignal,
|
|
fetch: fetch2
|
|
}) => postToApi({
|
|
url,
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
...headers
|
|
},
|
|
body: {
|
|
content: JSON.stringify(body),
|
|
values: body
|
|
},
|
|
failedResponseHandler,
|
|
successfulResponseHandler,
|
|
abortSignal,
|
|
fetch: fetch2
|
|
});
|
|
var postFormDataToApi = async ({
|
|
url,
|
|
headers,
|
|
formData,
|
|
failedResponseHandler,
|
|
successfulResponseHandler,
|
|
abortSignal,
|
|
fetch: fetch2
|
|
}) => postToApi({
|
|
url,
|
|
headers,
|
|
body: {
|
|
content: formData,
|
|
values: Object.fromEntries(formData.entries())
|
|
},
|
|
failedResponseHandler,
|
|
successfulResponseHandler,
|
|
abortSignal,
|
|
fetch: fetch2
|
|
});
|
|
var postToApi = async ({
|
|
url,
|
|
headers = {},
|
|
body,
|
|
successfulResponseHandler,
|
|
failedResponseHandler,
|
|
abortSignal,
|
|
fetch: fetch2 = getOriginalFetch2()
|
|
}) => {
|
|
try {
|
|
const response = await fetch2(url, {
|
|
method: "POST",
|
|
headers: withUserAgentSuffix(
|
|
headers,
|
|
`ai-sdk/provider-utils/${VERSION}`,
|
|
getRuntimeEnvironmentUserAgent()
|
|
),
|
|
body: body.content,
|
|
signal: abortSignal
|
|
});
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
if (!response.ok) {
|
|
let errorInformation;
|
|
try {
|
|
errorInformation = await failedResponseHandler({
|
|
response,
|
|
url,
|
|
requestBodyValues: body.values
|
|
});
|
|
} catch (error) {
|
|
if (isAbortError(error) || import_provider11.APICallError.isInstance(error)) {
|
|
throw error;
|
|
}
|
|
throw new import_provider11.APICallError({
|
|
message: "Failed to process error response",
|
|
cause: error,
|
|
statusCode: response.status,
|
|
url,
|
|
responseHeaders,
|
|
requestBodyValues: body.values
|
|
});
|
|
}
|
|
throw errorInformation.value;
|
|
}
|
|
try {
|
|
return await successfulResponseHandler({
|
|
response,
|
|
url,
|
|
requestBodyValues: body.values
|
|
});
|
|
} catch (error) {
|
|
if (error instanceof Error) {
|
|
if (isAbortError(error) || import_provider11.APICallError.isInstance(error)) {
|
|
throw error;
|
|
}
|
|
}
|
|
throw new import_provider11.APICallError({
|
|
message: "Failed to process successful response",
|
|
cause: error,
|
|
statusCode: response.status,
|
|
url,
|
|
responseHeaders,
|
|
requestBodyValues: body.values
|
|
});
|
|
}
|
|
} catch (error) {
|
|
throw handleFetchError({ error, url, requestBodyValues: body.values });
|
|
}
|
|
};
|
|
|
|
// src/types/tool.ts
|
|
function tool(tool2) {
|
|
return tool2;
|
|
}
|
|
function dynamicTool(tool2) {
|
|
return { ...tool2, type: "dynamic" };
|
|
}
|
|
|
|
// src/provider-tool-factory.ts
|
|
function createProviderToolFactory({
|
|
id,
|
|
inputSchema
|
|
}) {
|
|
return ({
|
|
execute,
|
|
outputSchema,
|
|
needsApproval,
|
|
toModelOutput,
|
|
onInputStart,
|
|
onInputDelta,
|
|
onInputAvailable,
|
|
...args
|
|
}) => tool({
|
|
type: "provider",
|
|
id,
|
|
args,
|
|
inputSchema,
|
|
outputSchema,
|
|
execute,
|
|
needsApproval,
|
|
toModelOutput,
|
|
onInputStart,
|
|
onInputDelta,
|
|
onInputAvailable
|
|
});
|
|
}
|
|
function createProviderToolFactoryWithOutputSchema({
|
|
id,
|
|
inputSchema,
|
|
outputSchema,
|
|
supportsDeferredResults
|
|
}) {
|
|
return ({
|
|
execute,
|
|
needsApproval,
|
|
toModelOutput,
|
|
onInputStart,
|
|
onInputDelta,
|
|
onInputAvailable,
|
|
...args
|
|
}) => tool({
|
|
type: "provider",
|
|
id,
|
|
args,
|
|
inputSchema,
|
|
outputSchema,
|
|
execute,
|
|
needsApproval,
|
|
toModelOutput,
|
|
onInputStart,
|
|
onInputDelta,
|
|
onInputAvailable,
|
|
supportsDeferredResults
|
|
});
|
|
}
|
|
|
|
// src/remove-undefined-entries.ts
|
|
function removeUndefinedEntries(record) {
|
|
return Object.fromEntries(
|
|
Object.entries(record).filter(([_key, value]) => value != null)
|
|
);
|
|
}
|
|
|
|
// src/resolve.ts
|
|
async function resolve(value) {
|
|
if (typeof value === "function") {
|
|
value = value();
|
|
}
|
|
return Promise.resolve(value);
|
|
}
|
|
|
|
// src/response-handler.ts
|
|
var import_provider12 = require("@ai-sdk/provider");
|
|
var createJsonErrorResponseHandler = ({
|
|
errorSchema,
|
|
errorToMessage,
|
|
isRetryable
|
|
}) => async ({ response, url, requestBodyValues }) => {
|
|
const responseBody = await response.text();
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
if (responseBody.trim() === "") {
|
|
return {
|
|
responseHeaders,
|
|
value: new import_provider12.APICallError({
|
|
message: response.statusText,
|
|
url,
|
|
requestBodyValues,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody,
|
|
isRetryable: isRetryable == null ? void 0 : isRetryable(response)
|
|
})
|
|
};
|
|
}
|
|
try {
|
|
const parsedError = await parseJSON({
|
|
text: responseBody,
|
|
schema: errorSchema
|
|
});
|
|
return {
|
|
responseHeaders,
|
|
value: new import_provider12.APICallError({
|
|
message: errorToMessage(parsedError),
|
|
url,
|
|
requestBodyValues,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody,
|
|
data: parsedError,
|
|
isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
|
|
})
|
|
};
|
|
} catch (parseError) {
|
|
return {
|
|
responseHeaders,
|
|
value: new import_provider12.APICallError({
|
|
message: response.statusText,
|
|
url,
|
|
requestBodyValues,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody,
|
|
isRetryable: isRetryable == null ? void 0 : isRetryable(response)
|
|
})
|
|
};
|
|
}
|
|
};
|
|
var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
if (response.body == null) {
|
|
throw new import_provider12.EmptyResponseBodyError({});
|
|
}
|
|
return {
|
|
responseHeaders,
|
|
value: parseJsonEventStream({
|
|
stream: response.body,
|
|
schema: chunkSchema
|
|
})
|
|
};
|
|
};
|
|
var createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
|
|
const responseBody = await response.text();
|
|
const parsedResult = await safeParseJSON({
|
|
text: responseBody,
|
|
schema: responseSchema
|
|
});
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
if (!parsedResult.success) {
|
|
throw new import_provider12.APICallError({
|
|
message: "Invalid JSON response",
|
|
cause: parsedResult.error,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody,
|
|
url,
|
|
requestBodyValues
|
|
});
|
|
}
|
|
return {
|
|
responseHeaders,
|
|
value: parsedResult.value,
|
|
rawValue: parsedResult.rawValue
|
|
};
|
|
};
|
|
var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
if (!response.body) {
|
|
throw new import_provider12.APICallError({
|
|
message: "Response body is empty",
|
|
url,
|
|
requestBodyValues,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody: void 0
|
|
});
|
|
}
|
|
try {
|
|
const buffer = await response.arrayBuffer();
|
|
return {
|
|
responseHeaders,
|
|
value: new Uint8Array(buffer)
|
|
};
|
|
} catch (error) {
|
|
throw new import_provider12.APICallError({
|
|
message: "Failed to read response as array buffer",
|
|
url,
|
|
requestBodyValues,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody: void 0,
|
|
cause: error
|
|
});
|
|
}
|
|
};
|
|
var createStatusCodeErrorResponseHandler = () => async ({ response, url, requestBodyValues }) => {
|
|
const responseHeaders = extractResponseHeaders(response);
|
|
const responseBody = await response.text();
|
|
return {
|
|
responseHeaders,
|
|
value: new import_provider12.APICallError({
|
|
message: response.statusText,
|
|
url,
|
|
requestBodyValues,
|
|
statusCode: response.status,
|
|
responseHeaders,
|
|
responseBody
|
|
})
|
|
};
|
|
};
|
|
|
|
// src/strip-file-extension.ts
|
|
function stripFileExtension(filename) {
|
|
const firstDotIndex = filename.indexOf(".");
|
|
return firstDotIndex === -1 ? filename : filename.slice(0, firstDotIndex);
|
|
}
|
|
|
|
// src/without-trailing-slash.ts
|
|
function withoutTrailingSlash(url) {
|
|
return url == null ? void 0 : url.replace(/\/$/, "");
|
|
}
|
|
|
|
// src/is-async-iterable.ts
|
|
function isAsyncIterable(obj) {
|
|
return obj != null && typeof obj[Symbol.asyncIterator] === "function";
|
|
}
|
|
|
|
// src/types/execute-tool.ts
|
|
async function* executeTool({
|
|
execute,
|
|
input,
|
|
options
|
|
}) {
|
|
const result = execute(input, options);
|
|
if (isAsyncIterable(result)) {
|
|
let lastOutput;
|
|
for await (const output of result) {
|
|
lastOutput = output;
|
|
yield { type: "preliminary", output };
|
|
}
|
|
yield { type: "final", output: lastOutput };
|
|
} else {
|
|
yield { type: "final", output: await result };
|
|
}
|
|
}
|
|
|
|
// src/index.ts
|
|
var import_stream2 = require("eventsource-parser/stream");
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
DEFAULT_MAX_DOWNLOAD_SIZE,
|
|
DelayedPromise,
|
|
DownloadError,
|
|
EventSourceParserStream,
|
|
VERSION,
|
|
asSchema,
|
|
combineHeaders,
|
|
convertAsyncIteratorToReadableStream,
|
|
convertBase64ToUint8Array,
|
|
convertImageModelFileToDataUri,
|
|
convertToBase64,
|
|
convertToFormData,
|
|
convertUint8ArrayToBase64,
|
|
createBinaryResponseHandler,
|
|
createEventSourceResponseHandler,
|
|
createIdGenerator,
|
|
createJsonErrorResponseHandler,
|
|
createJsonResponseHandler,
|
|
createProviderToolFactory,
|
|
createProviderToolFactoryWithOutputSchema,
|
|
createStatusCodeErrorResponseHandler,
|
|
createToolNameMapping,
|
|
delay,
|
|
downloadBlob,
|
|
dynamicTool,
|
|
executeTool,
|
|
extractResponseHeaders,
|
|
generateId,
|
|
getErrorMessage,
|
|
getFromApi,
|
|
getRuntimeEnvironmentUserAgent,
|
|
injectJsonInstructionIntoMessages,
|
|
isAbortError,
|
|
isNonNullable,
|
|
isParsableJson,
|
|
isUrlSupported,
|
|
jsonSchema,
|
|
lazySchema,
|
|
loadApiKey,
|
|
loadOptionalSetting,
|
|
loadSetting,
|
|
mediaTypeToExtension,
|
|
normalizeHeaders,
|
|
parseJSON,
|
|
parseJsonEventStream,
|
|
parseProviderOptions,
|
|
postFormDataToApi,
|
|
postJsonToApi,
|
|
postToApi,
|
|
readResponseWithSizeLimit,
|
|
removeUndefinedEntries,
|
|
resolve,
|
|
safeParseJSON,
|
|
safeValidateTypes,
|
|
stripFileExtension,
|
|
tool,
|
|
validateDownloadUrl,
|
|
validateTypes,
|
|
withUserAgentSuffix,
|
|
withoutTrailingSlash,
|
|
zodSchema
|
|
});
|
|
//# sourceMappingURL=index.js.map
|