"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 name in all)
__defProp(target, name, { get: all[name], 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// 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 src_exports = {};
__export(src_exports, {
EventSourceParserStream: () => import_stream2.EventSourceParserStream,
VERSION: () => VERSION,
asSchema: () => asSchema,
asValidator: () => asValidator,
combineHeaders: () => combineHeaders,
convertAsyncIteratorToReadableStream: () => convertAsyncIteratorToReadableStream,
convertBase64ToUint8Array: () => convertBase64ToUint8Array,
convertToBase64: () => convertToBase64,
convertUint8ArrayToBase64: () => convertUint8ArrayToBase64,
createBinaryResponseHandler: () => createBinaryResponseHandler,
createEventSourceResponseHandler: () => createEventSourceResponseHandler,
createIdGenerator: () => createIdGenerator,
createJsonErrorResponseHandler: () => createJsonErrorResponseHandler,
createJsonResponseHandler: () => createJsonResponseHandler,
createJsonStreamResponseHandler: () => createJsonStreamResponseHandler,
createProviderDefinedToolFactory: () => createProviderDefinedToolFactory,
createProviderDefinedToolFactoryWithOutputSchema: () => createProviderDefinedToolFactoryWithOutputSchema,
createStatusCodeErrorResponseHandler: () => createStatusCodeErrorResponseHandler,
delay: () => delay,
dynamicTool: () => dynamicTool,
executeTool: () => executeTool,
extractResponseHeaders: () => extractResponseHeaders,
generateId: () => generateId,
getErrorMessage: () => getErrorMessage,
getFromApi: () => getFromApi,
getRuntimeEnvironmentUserAgent: () => getRuntimeEnvironmentUserAgent,
injectJsonInstructionIntoMessages: () => injectJsonInstructionIntoMessages,
isAbortError: () => isAbortError,
isParsableJson: () => isParsableJson,
isUrlSupported: () => isUrlSupported,
isValidator: () => isValidator,
jsonSchema: () => jsonSchema,
lazySchema: () => lazySchema,
lazyValidator: () => lazyValidator,
loadApiKey: () => loadApiKey,
loadOptionalSetting: () => loadOptionalSetting,
loadSetting: () => loadSetting,
mediaTypeToExtension: () => mediaTypeToExtension,
normalizeHeaders: () => normalizeHeaders,
parseJSON: () => parseJSON,
parseJsonEventStream: () => parseJsonEventStream,
parseProviderOptions: () => parseProviderOptions,
postFormDataToApi: () => postFormDataToApi,
postJsonToApi: () => postJsonToApi,
postToApi: () => postToApi,
removeUndefinedEntries: () => removeUndefinedEntries,
resolve: () => resolve,
safeParseJSON: () => safeParseJSON,
safeValidateTypes: () => safeValidateTypes,
standardSchemaValidator: () => standardSchemaValidator,
tool: () => tool,
validateTypes: () => validateTypes,
validator: () => validator,
withUserAgentSuffix: () => withUserAgentSuffix,
withoutTrailingSlash: () => withoutTrailingSlash,
zodSchema: () => zodSchema
});
module.exports = __toCommonJS(src_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/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/extract-response-headers.ts
function extractResponseHeaders(response) {
return Object.fromEntries([...response.headers]);
}
// src/generate-id.ts
var import_provider = 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_provider.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_provider3 = require("@ai-sdk/provider");
// src/handle-fetch-error.ts
var import_provider2 = 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"];
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_provider2.APICallError({
message: `Cannot connect to API: ${cause.message}`,
cause,
url,
requestBodyValues,
isRetryable: true
// retry when network error
});
}
}
return error;
}
// src/get-runtime-environment-user-agent.ts
function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
var _a, _b, _c;
if (globalThisAny.window) {
return `runtime/browser`;
}
if ((_a = globalThisAny.navigator) == null ? void 0 : _a.userAgent) {
return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
}
if ((_c = (_b = globalThisAny.process) == null ? void 0 : _b.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 ? "3.0.17" : "0.0.0-test";
// src/get-from-api.ts
var getOriginalFetch = () => globalThis.fetch;
var getFromApi = async ({
url,
headers = {},
successfulResponseHandler,
failedResponseHandler,
abortSignal,
fetch = getOriginalFetch()
}) => {
try {
const response = await fetch(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_provider3.APICallError.isInstance(error)) {
throw error;
}
throw new import_provider3.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_provider3.APICallError.isInstance(error)) {
throw error;
}
}
throw new import_provider3.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 _a, _b;
const systemMessage = ((_a = messages[0]) == null ? void 0 : _a.role) === "system" ? { ...messages[0] } : { role: "system", content: "" };
systemMessage.content = injectJsonInstruction({
prompt: systemMessage.content,
schema,
schemaPrefix,
schemaSuffix
});
return [
systemMessage,
...((_b = messages[0]) == null ? void 0 : _b.role) === "system" ? messages.slice(1) : messages
];
}
// 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_provider4 = require("@ai-sdk/provider");
function loadApiKey({
apiKey,
environmentVariableName,
apiKeyParameterName = "apiKey",
description
}) {
if (typeof apiKey === "string") {
return apiKey;
}
if (apiKey != null) {
throw new import_provider4.LoadAPIKeyError({
message: `${description} API key must be a string.`
});
}
if (typeof process === "undefined") {
throw new import_provider4.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 import_provider4.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_provider4.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_provider5 = require("@ai-sdk/provider");
function loadSetting({
settingValue,
environmentVariableName,
settingName,
description
}) {
if (typeof settingValue === "string") {
return settingValue;
}
if (settingValue != null) {
throw new import_provider5.LoadSettingError({
message: `${description} setting must be a string.`
});
}
if (typeof process === "undefined") {
throw new import_provider5.LoadSettingError({
message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables is not supported in this environment.`
});
}
settingValue = process.env[environmentVariableName];
if (settingValue == null) {
throw new import_provider5.LoadSettingError({
message: `${description} setting is missing. Pass it using the '${settingName}' parameter or the ${environmentVariableName} environment variable.`
});
}
if (typeof settingValue !== "string") {
throw new import_provider5.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 _a;
const [_type, subtype = ""] = mediaType.toLowerCase().split("/");
return (_a = {
mpeg: "mp3",
"x-wav": "wav",
opus: "ogg",
mp4: "m4a",
"x-m4a": "m4a"
}[subtype]) != null ? _a : subtype;
}
// src/parse-json.ts
var import_provider8 = require("@ai-sdk/provider");
// src/secure-json-parse.ts
var suspectProtoRx = /"__proto__"\s*:/;
var suspectConstructorRx = /"constructor"\s*:/;
function _parse(text) {
const obj = JSON.parse(text);
if (obj === null || typeof obj !== "object") {
return obj;
}
if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
return obj;
}
return filter(obj);
}
function filter(obj) {
let next = [obj];
while (next.length) {
const nodes = next;
next = [];
for (const node of nodes) {
if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
throw new SyntaxError("Object contains forbidden prototype property");
}
if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
throw new SyntaxError("Object contains forbidden prototype property");
}
for (const key in node) {
const value = node[key];
if (value && typeof value === "object") {
next.push(value);
}
}
}
}
return obj;
}
function secureJsonParse(text) {
const { stackTraceLimit } = Error;
try {
Error.stackTraceLimit = 0;
} catch (e) {
return _parse(text);
}
try {
return _parse(text);
} finally {
Error.stackTraceLimit = stackTraceLimit;
}
}
// src/validate-types.ts
var import_provider7 = require("@ai-sdk/provider");
// src/validator.ts
var import_provider6 = require("@ai-sdk/provider");
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 lazyValidator(createValidator) {
let validator2;
return () => {
if (validator2 == null) {
validator2 = createValidator();
}
return validator2;
};
}
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 import_provider6.TypeValidationError({
value,
cause: result.issues
})
};
});
}
// src/validate-types.ts
async function validateTypes({
value,
schema
}) {
const result = await safeValidateTypes({ value, schema });
if (!result.success) {
throw import_provider7.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: import_provider7.TypeValidationError.wrap({ value, cause: result.error }),
rawValue: value
};
} catch (error) {
return {
success: false,
error: import_provider7.TypeValidationError.wrap({ value, cause: error }),
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_provider8.JSONParseError.isInstance(error) || import_provider8.TypeValidationError.isInstance(error)) {
throw error;
}
throw new import_provider8.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_provider8.JSONParseError.isInstance(error) ? error : new import_provider8.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_provider9 = 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_provider9.InvalidArgumentError({
argument: "providerOptions",
message: `invalid ${provider} provider options`,
cause: parsedProviderOptions.error
});
}
return parsedProviderOptions.value;
}
// src/post-to-api.ts
var import_provider10 = require("@ai-sdk/provider");
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 postFormDataToApi = async ({
url,
headers,
formData,
failedResponseHandler,
successfulResponseHandler,
abortSignal,
fetch
}) => postToApi({
url,
headers,
body: {
content: formData,
values: Object.fromEntries(formData.entries())
},
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) || import_provider10.APICallError.isInstance(error)) {
throw error;
}
throw new import_provider10.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_provider10.APICallError.isInstance(error)) {
throw error;
}
}
throw new import_provider10.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-defined-tool-factory.ts
function createProviderDefinedToolFactory({
id,
name,
inputSchema
}) {
return ({
execute,
outputSchema,
toModelOutput,
onInputStart,
onInputDelta,
onInputAvailable,
...args
}) => tool({
type: "provider-defined",
id,
name,
args,
inputSchema,
outputSchema,
execute,
toModelOutput,
onInputStart,
onInputDelta,
onInputAvailable
});
}
function createProviderDefinedToolFactoryWithOutputSchema({
id,
name,
inputSchema,
outputSchema
}) {
return ({
execute,
toModelOutput,
onInputStart,
onInputDelta,
onInputAvailable,
...args
}) => tool({
type: "provider-defined",
id,
name,
args,
inputSchema,
outputSchema,
execute,
toModelOutput,
onInputStart,
onInputDelta,
onInputAvailable
});
}
// 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_provider11 = 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_provider11.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_provider11.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_provider11.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_provider11.EmptyResponseBodyError({});
}
return {
responseHeaders,
value: parseJsonEventStream({
stream: response.body,
schema: chunkSchema
})
};
};
var createJsonStreamResponseHandler = (chunkSchema) => async ({ response }) => {
const responseHeaders = extractResponseHeaders(response);
if (response.body == null) {
throw new import_provider11.EmptyResponseBodyError({});
}
let buffer = "";
return {
responseHeaders,
value: response.body.pipeThrough(new TextDecoderStream()).pipeThrough(
new TransformStream({
async transform(chunkText, controller) {
if (chunkText.endsWith("\n")) {
controller.enqueue(
await safeParseJSON({
text: buffer + chunkText,
schema: chunkSchema
})
);
buffer = "";
} else {
buffer += chunkText;
}
}
})
)
};
};
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_provider11.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_provider11.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_provider11.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_provider11.APICallError({
message: response.statusText,
url,
requestBodyValues,
statusCode: response.status,
responseHeaders,
responseBody
})
};
};
// src/zod-schema.ts
var z4 = __toESM(require("zod/v4"));
// src/zod-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/zod-to-json-schema/options.ts
var ignoreOverride = 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/zod-to-json-schema/select-parser.ts
var import_v33 = require("zod/v3");
// src/zod-to-json-schema/parsers/any.ts
function parseAnyDef() {
return {};
}
// src/zod-to-json-schema/parsers/array.ts
var import_v3 = require("zod/v3");
function parseArrayDef(def, refs) {
var _a, _b, _c;
const res = {
type: "array"
};
if (((_a = def.type) == null ? void 0 : _a._def) && ((_c = (_b = def.type) == null ? void 0 : _b._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/zod-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/zod-to-json-schema/parsers/boolean.ts
function parseBooleanDef() {
return { type: "boolean" };
}
// src/zod-to-json-schema/parsers/branded.ts
function parseBrandedDef(_def, refs) {
return parseDef(_def.type._def, refs);
}
// src/zod-to-json-schema/parsers/catch.ts
var parseCatchDef = (def, refs) => {
return parseDef(def.innerType._def, refs);
};
// src/zod-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/zod-to-json-schema/parsers/default.ts
function parseDefaultDef(_def, refs) {
return {
...parseDef(_def.innerType._def, refs),
default: _def.defaultValue()
};
}
// src/zod-to-json-schema/parsers/effects.ts
function parseEffectsDef(_def, refs) {
return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
}
// src/zod-to-json-schema/parsers/enum.ts
function parseEnumDef(def) {
return {
type: "string",
enum: Array.from(def.values)
};
}
// src/zod-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/zod-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/zod-to-json-schema/parsers/record.ts
var import_v32 = require("zod/v3");
// src/zod-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 _a;
if (schema.format || ((_a = schema.anyOf) == null ? void 0 : _a.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 _a;
if (schema.pattern || ((_a = schema.allOf) == null ? void 0 : _a.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 _a;
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] === "-" && ((_a = source[i + 2]) == null ? void 0 : _a.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/zod-to-json-schema/parsers/record.ts
function parseRecordDef(def, refs) {
var _a, _b, _c, _d, _e, _f;
const schema = {
type: "object",
additionalProperties: (_a = parseDef(def.valueType._def, {
...refs,
currentPath: [...refs.currentPath, "additionalProperties"]
})) != null ? _a : refs.allowedAdditionalProperties
};
if (((_b = def.keyType) == null ? void 0 : _b._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/zod-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/zod-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/zod-to-json-schema/parsers/never.ts
function parseNeverDef() {
return { not: parseAnyDef() };
}
// src/zod-to-json-schema/parsers/null.ts
function parseNullDef() {
return {
type: "null"
};
}
// src/zod-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/zod-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/zod-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/zod-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/zod-to-json-schema/parsers/optional.ts
var parseOptionalDef = (def, refs) => {
var _a;
if (refs.currentPath.toString() === ((_a = refs.propertyPath) == null ? void 0 : _a.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/zod-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/zod-to-json-schema/parsers/promise.ts
function parsePromiseDef(def, refs) {
return parseDef(def.type._def, refs);
}
// src/zod-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/zod-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/zod-to-json-schema/parsers/undefined.ts
function parseUndefinedDef() {
return {
not: parseAnyDef()
};
}
// src/zod-to-json-schema/parsers/unknown.ts
function parseUnknownDef() {
return parseAnyDef();
}
// src/zod-to-json-schema/parsers/readonly.ts
var parseReadonlyDef = (def, refs) => {
return parseDef(def.innerType._def, refs);
};
// src/zod-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/zod-to-json-schema/parse-def.ts
function parseDef(def, refs, forceResolution = false) {
var _a;
const seenItem = refs.seen.get(def);
if (refs.override) {
const overrideResult = (_a = refs.override) == null ? void 0 : _a.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/zod-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(([name, def]) => [
def._def,
{
def: def._def,
path: [..._options.basePath, _options.definitionPath, name],
// 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/zod-to-json-schema/zod-to-json-schema.ts
var zodToJsonSchema = (schema, options) => {
var _a;
const refs = getRefs(options);
let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
(acc, [name2, schema2]) => {
var _a2;
return {
...acc,
[name2]: (_a2 = parseDef(
schema2._def,
{
...refs,
currentPath: [...refs.basePath, refs.definitionPath, name2]
},
true
)) != null ? _a2 : parseAnyDef()
};
},
{}
) : void 0;
const name = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
const main = (_a = parseDef(
schema._def,
name === void 0 ? refs : {
...refs,
currentPath: [...refs.basePath, refs.definitionPath, name]
},
false
)) != null ? _a : 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 = name === void 0 ? definitions ? {
...main,
[refs.definitionPath]: definitions
} : main : {
$ref: [
...refs.$refStrategy === "relative" ? [] : refs.basePath,
refs.definitionPath,
name
].join("/"),
[refs.definitionPath]: {
...definitions,
[name]: main
}
};
combined.$schema = "http://json-schema.org/draft-07/schema#";
return combined;
};
// src/zod-to-json-schema/index.ts
var zod_to_json_schema_default = zodToJsonSchema;
// src/zod-schema.ts
function zod3Schema(zodSchema2, options) {
var _a;
const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
return jsonSchema(
// defer json schema creation to avoid unnecessary computation when only validation is needed
() => zod_to_json_schema_default(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 _a;
const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
return jsonSchema(
// defer json schema creation to avoid unnecessary computation when only validation is needed
() => z4.toJSONSchema(zodSchema2, {
target: "draft-7",
io: "output",
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/schema.ts
var schemaSymbol = 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
[validatorSymbol]: true,
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 : typeof schema === "function" ? schema() : zodSchema(schema);
}
// 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/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
__reExport(src_exports, require("@standard-schema/spec"), module.exports);
var import_stream2 = require("eventsource-parser/stream");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
EventSourceParserStream,
VERSION,
asSchema,
asValidator,
combineHeaders,
convertAsyncIteratorToReadableStream,
convertBase64ToUint8Array,
convertToBase64,
convertUint8ArrayToBase64,
createBinaryResponseHandler,
createEventSourceResponseHandler,
createIdGenerator,
createJsonErrorResponseHandler,
createJsonResponseHandler,
createJsonStreamResponseHandler,
createProviderDefinedToolFactory,
createProviderDefinedToolFactoryWithOutputSchema,
createStatusCodeErrorResponseHandler,
delay,
dynamicTool,
executeTool,
extractResponseHeaders,
generateId,
getErrorMessage,
getFromApi,
getRuntimeEnvironmentUserAgent,
injectJsonInstructionIntoMessages,
isAbortError,
isParsableJson,
isUrlSupported,
isValidator,
jsonSchema,
lazySchema,
lazyValidator,
loadApiKey,
loadOptionalSetting,
loadSetting,
mediaTypeToExtension,
normalizeHeaders,
parseJSON,
parseJsonEventStream,
parseProviderOptions,
postFormDataToApi,
postJsonToApi,
postToApi,
removeUndefinedEntries,
resolve,
safeParseJSON,
safeValidateTypes,
standardSchemaValidator,
tool,
validateTypes,
validator,
withUserAgentSuffix,
withoutTrailingSlash,
zodSchema,
...require("@standard-schema/spec")
});
//# sourceMappingURL=index.js.map
