palettecn 0.1.0

package/dist/web/server/_libs/ai-sdk__provider-utils.mjs

@@ -0,0 +1,411 @@
+import { Y as EventSourceParserStream } from "./@ai-sdk/anthropic+[...].mjs";
+import { a as JSONParseError, c as TypeValidationError, n as EmptyResponseBodyError, o as LoadAPIKeyError, r as InvalidArgumentError, t as APICallError } from "./ai-sdk__provider.mjs";
+//#region ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.22_zod@4.3.6/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+function combineHeaders(...headers) {
+	return headers.reduce((combinedHeaders, currentHeaders) => ({
+		...combinedHeaders,
+		...currentHeaders != null ? currentHeaders : {}
+	}), {});
+}
+function extractResponseHeaders(response) {
+	return Object.fromEntries([...response.headers]);
+}
+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 InvalidArgumentError({
+		argument: "separator",
+		message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+	});
+	return () => `${prefix}${separator}${generator()}`;
+};
+var generateId = createIdGenerator();
+function isAbortError(error) {
+	return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || error.name === "TimeoutError");
+}
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+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 APICallError({
+			message: `Cannot connect to API: ${cause.message}`,
+			cause,
+			url,
+			requestBodyValues,
+			isRetryable: true
+		});
+	}
+	return error;
+}
+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";
+}
+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;
+}
+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());
+}
+var VERSION = "3.0.22";
+function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName = "apiKey", description }) {
+	if (typeof apiKey === "string") return apiKey;
+	if (apiKey != null) throw new LoadAPIKeyError({ message: `${description} API key must be a string.` });
+	if (typeof process === "undefined") throw new LoadAPIKeyError({ message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.` });
+	apiKey = process.env[environmentVariableName];
+	if (apiKey == null) throw new LoadAPIKeyError({ message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.` });
+	if (typeof apiKey !== "string") throw new LoadAPIKeyError({ message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.` });
+	return apiKey;
+}
+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;
+	}
+}
+var validatorSymbol = Symbol.for("vercel.ai.validator");
+function validator(validate) {
+	return {
+		[validatorSymbol]: true,
+		validate
+	};
+}
+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 : typeof value === "function" ? value() : standardSchemaValidator(value);
+}
+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 TypeValidationError({
+				value,
+				cause: result.issues
+			})
+		};
+	});
+}
+async function validateTypes({ value, schema }) {
+	const result = await safeValidateTypes({
+		value,
+		schema
+	});
+	if (!result.success) throw TypeValidationError.wrap({
+		value,
+		cause: result.error
+	});
+	return result.value;
+}
+async function safeValidateTypes({ value, schema }) {
+	const validator2 = asValidator(schema);
+	try {
+		if (validator2.validate == null) return {
+			success: true,
+			value,
+			rawValue: value
+		};
+		const result = await validator2.validate(value);
+		if (result.success) return {
+			success: true,
+			value: result.value,
+			rawValue: value
+		};
+		return {
+			success: false,
+			error: TypeValidationError.wrap({
+				value,
+				cause: result.error
+			}),
+			rawValue: value
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: TypeValidationError.wrap({
+				value,
+				cause: error
+			}),
+			rawValue: value
+		};
+	}
+}
+async function parseJSON({ text, schema }) {
+	try {
+		const value = secureJsonParse(text);
+		if (schema == null) return value;
+		return validateTypes({
+			value,
+			schema
+		});
+	} catch (error) {
+		if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) throw error;
+		throw new 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: JSONParseError.isInstance(error) ? error : new JSONParseError({
+				text,
+				cause: error
+			}),
+			rawValue: void 0
+		};
+	}
+}
+function isParsableJson(input) {
+	try {
+		secureJsonParse(input);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+function parseJsonEventStream({ stream, schema }) {
+	return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(new TransformStream({ async transform({ data }, controller) {
+		if (data === "[DONE]") return;
+		controller.enqueue(await safeParseJSON({
+			text: data,
+			schema
+		}));
+	} }));
+}
+var getOriginalFetch2 = () => globalThis.fetch;
+var postJsonToApi = async ({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }) => postToApi({
+	url,
+	headers: {
+		"Content-Type": "application/json",
+		...headers
+	},
+	body: {
+		content: JSON.stringify(body),
+		values: body
+	},
+	failedResponseHandler,
+	successfulResponseHandler,
+	abortSignal,
+	fetch
+});
+var postToApi = async ({ url, headers = {}, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch = getOriginalFetch2() }) => {
+	try {
+		const response = await fetch(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) || APICallError.isInstance(error)) throw error;
+				throw new 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) || APICallError.isInstance(error)) throw error;
+			}
+			throw new 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
+		});
+	}
+};
+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 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 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 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 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 APICallError({
+		message: "Invalid JSON response",
+		cause: parsedResult.error,
+		statusCode: response.status,
+		responseHeaders,
+		responseBody,
+		url,
+		requestBodyValues
+	});
+	return {
+		responseHeaders,
+		value: parsedResult.value,
+		rawValue: parsedResult.rawValue
+	};
+};
+var { btoa, atob } = globalThis;
+function convertUint8ArrayToBase64(array) {
+	let latin1string = "";
+	for (let i = 0; i < array.length; i++) latin1string += String.fromCodePoint(array[i]);
+	return btoa(latin1string);
+}
+function withoutTrailingSlash(url) {
+	return url == null ? void 0 : url.replace(/\/$/, "");
+}
+//#endregion
+export { createJsonResponseHandler as a, loadApiKey as c, createJsonErrorResponseHandler as i, postJsonToApi as l, convertUint8ArrayToBase64 as n, generateId as o, createEventSourceResponseHandler as r, isParsableJson as s, combineHeaders as t, withoutTrailingSlash as u };

package/dist/web/server/_libs/ai-sdk__provider.mjs

@@ -0,0 +1,222 @@
+//#region ../../node_modules/.pnpm/@ai-sdk+provider@2.0.1/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a, _b;
+var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
+	/**
+	* Creates an AI SDK Error.
+	*
+	* @param {Object} params - The parameters for creating the error.
+	* @param {string} params.name - The name of the error.
+	* @param {string} params.message - The error message.
+	* @param {unknown} [params.cause] - The underlying cause of the error.
+	*/
+	constructor({ name: name14, message, cause }) {
+		super(message);
+		this[_a] = true;
+		this.name = name14;
+		this.cause = cause;
+	}
+	/**
+	* Checks if the given error is an AI SDK Error.
+	* @param {unknown} error - The error to check.
+	* @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+	*/
+	static isInstance(error) {
+		return _AISDKError.hasMarker(error, marker);
+	}
+	static hasMarker(error, marker15) {
+		const markerSymbol = Symbol.for(marker15);
+		return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+	}
+};
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2, _b2;
+var APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
+	constructor({ message, url, requestBodyValues, statusCode, responseHeaders, responseBody, cause, isRetryable = statusCode != null && (statusCode === 408 || statusCode === 409 || statusCode === 429 || statusCode >= 500), data }) {
+		super({
+			name,
+			message,
+			cause
+		});
+		this[_a2] = true;
+		this.url = url;
+		this.requestBodyValues = requestBodyValues;
+		this.statusCode = statusCode;
+		this.responseHeaders = responseHeaders;
+		this.responseBody = responseBody;
+		this.isRetryable = isRetryable;
+		this.data = data;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker2);
+	}
+};
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3, _b3;
+var EmptyResponseBodyError = class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
+	constructor({ message = "Empty response body" } = {}) {
+		super({
+			name: name2,
+			message
+		});
+		this[_a3] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker3);
+	}
+};
+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);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4, _b4;
+var InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
+	constructor({ message, cause, argument }) {
+		super({
+			name: name3,
+			message,
+			cause
+		});
+		this[_a4] = true;
+		this.argument = argument;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker4);
+	}
+};
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6, _b6;
+var InvalidResponseDataError = class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
+	constructor({ data, message = `Invalid response data: ${JSON.stringify(data)}.` }) {
+		super({
+			name: name5,
+			message
+		});
+		this[_a6] = true;
+		this.data = data;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker6);
+	}
+};
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7, _b7;
+var JSONParseError = class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
+	constructor({ text, cause }) {
+		super({
+			name: name6,
+			message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+			cause
+		});
+		this[_a7] = true;
+		this.text = text;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker7);
+	}
+};
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8, _b8;
+var LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
+	constructor({ message }) {
+		super({
+			name: name7,
+			message
+		});
+		this[_a8] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker8);
+	}
+};
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12, _b12;
+var TooManyEmbeddingValuesForCallError = class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
+	constructor(options) {
+		super({
+			name: name11,
+			message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+		});
+		this[_a12] = true;
+		this.provider = options.provider;
+		this.modelId = options.modelId;
+		this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+		this.values = options.values;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker12);
+	}
+};
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13, _b13;
+var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
+	constructor({ value, cause }) {
+		super({
+			name: name12,
+			message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+			cause
+		});
+		this[_a13] = true;
+		this.value = value;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker13);
+	}
+	/**
+	* Wraps an error into a TypeValidationError.
+	* If the cause is already a TypeValidationError with the same value, it returns the cause.
+	* Otherwise, it creates a new TypeValidationError.
+	*
+	* @param {Object} params - The parameters for wrapping the error.
+	* @param {unknown} params.value - The value that failed validation.
+	* @param {unknown} params.cause - The original error or cause of the validation failure.
+	* @returns {TypeValidationError} A TypeValidationError instance.
+	*/
+	static wrap({ value, cause }) {
+		return _TypeValidationError.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError({
+			value,
+			cause
+		});
+	}
+};
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14, _b14;
+var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
+	constructor({ functionality, message = `'${functionality}' functionality not supported.` }) {
+		super({
+			name: name13,
+			message
+		});
+		this[_a14] = true;
+		this.functionality = functionality;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker14);
+	}
+};
+//#endregion
+export { JSONParseError as a, TypeValidationError as c, InvalidResponseDataError as i, UnsupportedFunctionalityError as l, EmptyResponseBodyError as n, LoadAPIKeyError as o, InvalidArgumentError as r, TooManyEmbeddingValuesForCallError as s, APICallError as t };

package/dist/web/server/_libs/bail.mjs

@@ -0,0 +1,13 @@
+//#region ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
+/**
+* Throw a given error.
+*
+* @param {Error|null|undefined} [error]
+*   Maybe error.
+* @returns {asserts error is null|undefined}
+*/
+function bail(error) {
+	if (error) throw error;
+}
+//#endregion
+export { bail as t };