@alint-js/plugin-js 0.0.28 → 0.0.29

package/dist/index.mjs

@@ -1,6 +1,14 @@
-import { definePlugin, defineRule } from "@alint-js/core";
-import { formatOutputLanguageInstruction, formatSourceWithLineNumbers, generateStructured, toolParametersFromSchema } from "@alint-js/core/structured-output";
-import { array, boolean, description, number, object, picklist, pipe, string } from "valibot";
+import { n as strictJsonSchema } from "./index-DoHiaFQM-9scNuUlY.mjs";
+import { t as __exportAll } from "./esm-F2YJn-T8.mjs";
+import { setTimeout } from "node:timers/promises";
+//#region ../plugin/dist/index.mjs
+function definePlugin(plugin) {
+	return plugin;
+}
+function defineRule(rule) {
+	return rule;
+}
+//#endregion
 //#region src/rules/inline-miniature-normalizer/prompt.ts
 const inlineMiniatureNormalizerPrompt = `
 You are reviewing one TypeScript file.
@@ -46,31 +54,1682 @@ Do not report:
 Return warnings only. If uncertain, use medium or low confidence instead of forcing a finding.
 `.trim();
 //#endregion
+//#region ../../node_modules/.pnpm/@moeru+std@0.1.0-beta.20/node_modules/@moeru/std/dist/error/index.js
+const isError = (err) => {
+	if ("isError" in Error && Error.isError(new DOMException())) return Error.isError(err);
+	if (err === null || typeof err !== "object" && typeof err !== "function") return false;
+	if (err instanceof Error) return true;
+	const tag = Object.prototype.toString.call(err);
+	return tag === "[object DOMException]" || tag === "[object Error]";
+};
+const isErrorLike = (err) => {
+	if (isError(err)) return true;
+	if (err == null || typeof err !== "object" && typeof err !== "function") return false;
+	return "message" in err && typeof err.message === "string" && "name" in err && typeof err.name === "string";
+};
+const errorMessageFrom = (err) => isErrorLike(err) ? err.message : err == null ? void 0 : String(err);
+const DEFAULT_CONFIG = {
+	lang: void 0,
+	message: void 0,
+	abortEarly: void 0,
+	abortPipeEarly: void 0
+};
+/**
+* Returns the global configuration.
+*
+* @param config The config to merge.
+*
+* @returns The configuration.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config$1) {
+	if (!config$1 && true) return DEFAULT_CONFIG;
+	return {
+		lang: config$1?.lang ?? void 0,
+		message: config$1?.message,
+		abortEarly: config$1?.abortEarly ?? void 0,
+		abortPipeEarly: config$1?.abortPipeEarly ?? void 0
+	};
+}
+/**
+* Stringifies an unknown input to a literal or type string.
+*
+* @param input The unknown input.
+*
+* @returns A literal or type string.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+/**
+* Adds an issue to the dataset.
+*
+* @param context The issue context.
+* @param label The issue label.
+* @param dataset The input dataset.
+* @param config The configuration.
+* @param other The optional props.
+*
+* @internal
+*/
+function _addIssue(context, label, dataset, config$1, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config$1.lang,
+		abortEarly: config$1.abortEarly,
+		abortPipeEarly: config$1.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message$1 = other?.message ?? context.message ?? (context.reference, issue.lang, void 0) ?? (isSchema ? (issue.lang, void 0) : null) ?? config$1.message ?? (issue.lang, void 0);
+	if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+/**
+* Returns the last top-level value of a given metadata type from a schema
+* using a breadth-first search that starts with the last item in the pipeline.
+*
+* @param schema The schema to search.
+* @param type The metadata type.
+*
+* @returns The value, if any.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _getLastMetadata(schema, type) {
+	if ("pipe" in schema) {
+		const nestedSchemas = [];
+		for (let index = schema.pipe.length - 1; index >= 0; index--) {
+			const item = schema.pipe[index];
+			if (item.kind === "schema" && "pipe" in item) nestedSchemas.push(item);
+			else if (item.kind === "metadata" && item.type === type) return item[type];
+		}
+		for (const nestedSchema of nestedSchemas) {
+			const result = /* @__PURE__ */ _getLastMetadata(nestedSchema, type);
+			if (result !== void 0) return result;
+		}
+	}
+}
+const _standardCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the Standard Schema properties.
+*
+* @param context The schema context.
+*
+* @returns The Standard Schema properties.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	let cached = _standardCache.get(context);
+	if (!cached) {
+		cached = {
+			version: 1,
+			vendor: "valibot",
+			validate(value$1) {
+				return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+			}
+		};
+		_standardCache.set(context, cached);
+	}
+	return cached;
+}
+/**
+* Joins multiple `expects` values with the given separator.
+*
+* @param values The `expects` values.
+* @param separator The separator.
+*
+* @returns The joined `expects` property.
+*
+* @internal
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values$1, separator) {
+	const list = [...new Set(values$1)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+/**
+* A Valibot error with useful information.
+*/
+var ValiError = class extends Error {
+	/**
+	* Creates a Valibot error with useful information.
+	*
+	* @param issues The error issues.
+	*/
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "ValiError";
+		this.issues = issues;
+	}
+};
+/**
+* Creates a description metadata action.
+*
+* @param description_ The description text.
+*
+* @returns A description action.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function description(description_) {
+	return {
+		kind: "metadata",
+		type: "description",
+		reference: description,
+		description: description_
+	};
+}
+/**
+* Returns the fallback value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The output dataset if available.
+* @param config The config if available.
+*
+* @returns The fallback value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config$1) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+/**
+* Returns the default value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The input dataset if available.
+* @param config The config if available.
+*
+* @returns The default value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config$1) {
+	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+/**
+* Returns the description of the schema.
+*
+* If multiple descriptions are defined, the last one of the highest level is
+* returned. If no description is defined, `undefined` is returned.
+*
+* @param schema The schema to get the description from.
+*
+* @returns The description, if any.
+*
+* @beta
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDescription(schema) {
+	return /* @__PURE__ */ _getLastMetadata(schema, "description");
+}
+/* @__NO_SIDE_EFFECTS__ */
+function array(item, message$1) {
+	return {
+		kind: "schema",
+		type: "array",
+		reference: array,
+		expects: "Array",
+		async: false,
+		item,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (Array.isArray(input)) {
+				dataset.typed = true;
+				dataset.value = [];
+				for (let key = 0; key < input.length; key++) {
+					const value$1 = input[key];
+					const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+					if (itemDataset.issues) {
+						const pathItem = {
+							type: "array",
+							origin: "value",
+							input,
+							key,
+							value: value$1
+						};
+						for (const issue of itemDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = itemDataset.issues;
+						if (config$1.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!itemDataset.typed) dataset.typed = false;
+					dataset.value.push(itemDataset.value);
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message$1) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function number(message$1) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries$1, message$1) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries$1,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value$1
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config$1.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config$1, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config$1.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function picklist(options, message$1) {
+	return {
+		kind: "schema",
+		type: "picklist",
+		reference: picklist,
+		expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+		async: false,
+		options,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (this.options.includes(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message$1) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config$1);
+			return dataset;
+		}
+	};
+}
+/**
+* Parses an unknown input based on a schema.
+*
+* @param schema The schema to be used.
+* @param input The input to be parsed.
+* @param config The parse configuration.
+*
+* @returns The parsed input.
+*/
+function parse(schema, input, config$1) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+	if (dataset.issues) throw new ValiError(dataset.issues);
+	return dataset.value;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe$1) {
+	return {
+		...pipe$1[0],
+		pipe: pipe$1,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config$1) {
+			for (const item of pipe$1) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+			}
+			return dataset;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@valibot+to-json-schema@1.7.1_valibot@1.4.2_typescript@6.0.3_/node_modules/@valibot/to-json-schema/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	addGlobalDefs: () => addGlobalDefs,
+	getGlobalDefs: () => getGlobalDefs,
+	toJsonSchema: () => toJsonSchema,
+	toJsonSchemaDefs: () => toJsonSchemaDefs,
+	toStandardJsonSchema: () => toStandardJsonSchema
+});
+/**
+* Adds an error message to the errors array.
+*
+* @param errors The array of error messages.
+* @param message The error message to add.
+*
+* @returns The new errors.
+*/
+function addError(errors, message) {
+	if (errors) {
+		errors.push(message);
+		return errors;
+	}
+	return [message];
+}
+const ESCAPE_REGEX = /[.*+?^${}()|[\]\\]/g;
+/**
+* Escapes special regex characters in a string.
+*
+* @param string The string to escape.
+*
+* @returns The escaped string.
+*/
+function escapeRegExp(string) {
+	return string.replace(ESCAPE_REGEX, "\\$&");
+}
+/**
+* Throws an error or logs a warning based on the configuration.
+*
+* @param message The message to throw or log.
+* @param config The conversion configuration.
+*/
+function handleError(message, config) {
+	switch (config?.errorMode) {
+		case "ignore": break;
+		case "warn":
+			console.warn(message);
+			break;
+		default: throw new Error(message);
+	}
+}
+/**
+* Whether a value is JSON compatible for a const keyword.
+*
+* @param value The value to check.
+*
+* @returns Whether the value is JSON compatible.
+*/
+function isJsonConstValue(value) {
+	return typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "string";
+}
+/**
+* Whether values are JSON compatible for an enum keyword.
+*
+* @param values The values to check.
+*
+* @returns Whether the values are JSON compatible.
+*/
+function isJsonEnumValues(values) {
+	return values.every(isJsonConstValue);
+}
+/**
+* Converts any supported Valibot action to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotAction The Valibot action object.
+* @param config The conversion configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function convertAction(jsonSchema, valibotAction, config) {
+	if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
+	let errors;
+	switch (valibotAction.type) {
+		case "base64":
+			jsonSchema.contentEncoding = "base64";
+			break;
+		case "bic":
+		case "cuid2":
+		case "decimal":
+		case "digits":
+		case "domain":
+		case "emoji":
+		case "hash":
+		case "hexadecimal":
+		case "hex_color":
+		case "isrc":
+		case "iso_time_second":
+		case "iso_week":
+		case "mac":
+		case "mac48":
+		case "mac64":
+		case "nanoid":
+		case "octal":
+		case "slug":
+		case "ulid":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "description":
+			jsonSchema.description = valibotAction.description;
+			break;
+		case "email":
+		case "rfc_email":
+			jsonSchema.format = "email";
+			break;
+		case "ends_with":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = `${escapeRegExp(valibotAction.requirement)}$`;
+			break;
+		case "empty":
+			if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = 0;
+			}
+			break;
+		case "entries":
+			jsonSchema.minProperties = valibotAction.requirement;
+			jsonSchema.maxProperties = valibotAction.requirement;
+			break;
+		case "examples":
+			if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.examples];
+			else jsonSchema.examples = valibotAction.examples;
+			break;
+		case "gt_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "gt_value" action is not supported on type "${jsonSchema.type}".`);
+			if (config?.target === "openapi-3.0") {
+				errors = addError(errors, "The \"gt_value\" action is not supported for OpenAPI 3.0.");
+				break;
+			}
+			jsonSchema.exclusiveMinimum = valibotAction.requirement;
+			break;
+		case "includes":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = escapeRegExp(valibotAction.requirement);
+			break;
+		case "integer":
+			jsonSchema.type = "integer";
+			break;
+		case "ipv4":
+			jsonSchema.format = "ipv4";
+			break;
+		case "ipv6":
+			jsonSchema.format = "ipv6";
+			break;
+		case "iso_date":
+			jsonSchema.format = "date";
+			break;
+		case "iso_date_time":
+		case "iso_timestamp":
+			jsonSchema.format = "date-time";
+			break;
+		case "iso_time":
+			jsonSchema.format = "time";
+			break;
+		case "jws_compact":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "length":
+			if (jsonSchema.type === "array") {
+				jsonSchema.minItems = valibotAction.requirement;
+				jsonSchema.maxItems = valibotAction.requirement;
+			} else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = valibotAction.requirement;
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		case "lt_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "lt_value" action is not supported on type "${jsonSchema.type}".`);
+			if (config?.target === "openapi-3.0") {
+				errors = addError(errors, "The \"lt_value\" action is not supported for OpenAPI 3.0.");
+				break;
+			}
+			jsonSchema.exclusiveMaximum = valibotAction.requirement;
+			break;
+		case "max_entries":
+			jsonSchema.maxProperties = valibotAction.requirement;
+			break;
+		case "max_length":
+			if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		case "max_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
+			jsonSchema.maximum = valibotAction.requirement;
+			break;
+		case "metadata":
+			if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
+			if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
+			if (Array.isArray(valibotAction.metadata.examples)) if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.metadata.examples];
+			else jsonSchema.examples = valibotAction.metadata.examples;
+			break;
+		case "min_entries":
+			jsonSchema.minProperties = valibotAction.requirement;
+			break;
+		case "min_length":
+			if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = valibotAction.requirement;
+			}
+			break;
+		case "min_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
+			jsonSchema.minimum = valibotAction.requirement;
+			break;
+		case "multiple_of":
+			jsonSchema.multipleOf = valibotAction.requirement;
+			break;
+		case "non_empty":
+			if (jsonSchema.type === "array") jsonSchema.minItems = 1;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = 1;
+			}
+			break;
+		case "not_value":
+			if (!isJsonConstValue(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"not_value\" action is not JSON compatible.");
+				break;
+			}
+			if (config?.target === "openapi-3.0") jsonSchema.not = { enum: [valibotAction.requirement] };
+			else jsonSchema.not = { const: valibotAction.requirement };
+			break;
+		case "not_values":
+			if (!isJsonEnumValues(valibotAction.requirement)) {
+				errors = addError(errors, "A requirement of the \"not_values\" action is not JSON compatible.");
+				break;
+			}
+			jsonSchema.not = { enum: valibotAction.requirement };
+			break;
+		case "regex":
+			if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "safe_integer":
+			jsonSchema.type = "integer";
+			if (typeof jsonSchema.minimum !== "number" || jsonSchema.minimum < Number.MIN_SAFE_INTEGER) jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
+			if (typeof jsonSchema.maximum !== "number" || jsonSchema.maximum > Number.MAX_SAFE_INTEGER) jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
+			break;
+		case "starts_with":
+			if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
+			else jsonSchema.pattern = `^${escapeRegExp(valibotAction.requirement)}`;
+			break;
+		case "title":
+			jsonSchema.title = valibotAction.title;
+			break;
+		case "url":
+			jsonSchema.format = "uri";
+			break;
+		case "uuid":
+			jsonSchema.format = "uuid";
+			break;
+		case "value":
+			if (!isJsonConstValue(valibotAction.requirement)) {
+				errors = addError(errors, "The requirement of the \"value\" action is not JSON compatible.");
+				break;
+			}
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotAction.requirement];
+			else jsonSchema.const = valibotAction.requirement;
+			break;
+		case "values":
+			if (!isJsonEnumValues(valibotAction.requirement)) {
+				errors = addError(errors, "A requirement of the \"values\" action is not JSON compatible.");
+				break;
+			}
+			jsonSchema.enum = valibotAction.requirement;
+			break;
+		default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideAction) {
+		const actionOverride = config.overrideAction({
+			valibotAction,
+			jsonSchema,
+			errors
+		});
+		if (actionOverride) return { ...actionOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+/**
+* Flattens a Valibot pipe by recursively expanding nested pipes.
+*
+* @param pipe The pipeline to flatten.
+*
+* @returns A flat pipeline.
+*/
+function flattenPipe(pipe) {
+	return pipe.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
+}
+/**
+* Returns the JSON Pointer reference for a definition key.
+*
+* @param referenceId The unescaped definition key.
+*
+* @returns The encoded JSON Pointer fragment.
+*/
+function getDefinitionRef(referenceId) {
+	return `#/$defs/${referenceId.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+let refCount = 0;
+/**
+* Converts any supported Valibot schema to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotSchema The Valibot schema object.
+* @param config The conversion configuration.
+* @param context The conversion context.
+* @param skipRef Whether to skip using a reference.
+*
+* @returns The converted JSON Schema.
+*/
+function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
+	if (!skipRef) {
+		const referenceId = context.referenceMap.get(valibotSchema);
+		if (referenceId) {
+			jsonSchema.$ref = getDefinitionRef(referenceId);
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			return jsonSchema;
+		}
+	}
+	if ("pipe" in valibotSchema) {
+		const flatPipe = flattenPipe(valibotSchema.pipe);
+		let startIndex = 0;
+		let stopIndex = flatPipe.length - 1;
+		if (config?.typeMode === "input") {
+			const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "to_bigint" || item.type === "to_boolean" || item.type === "to_date" || item.type === "to_number" || item.type === "to_string" || item.type === "transform"));
+			if (inputStopIndex !== -1) stopIndex = inputStopIndex;
+		} else if (config?.typeMode === "output") {
+			const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
+			if (outputStartIndex !== -1) startIndex = outputStartIndex;
+		}
+		for (let index = startIndex; index <= stopIndex; index++) {
+			const valibotPipeItem = flatPipe[index];
+			if (valibotPipeItem.kind === "schema") {
+				if (index > startIndex) handleError("Set the \"typeMode\" config to \"input\" or \"output\" to convert pipelines with multiple schemas.", config);
+				jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
+			} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
+		}
+		return jsonSchema;
+	}
+	let errors;
+	switch (valibotSchema.type) {
+		case "boolean":
+			jsonSchema.type = "boolean";
+			break;
+		case "null":
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [null];
+			else jsonSchema.type = "null";
+			break;
+		case "number":
+			jsonSchema.type = "number";
+			break;
+		case "string":
+			jsonSchema.type = "string";
+			break;
+		case "array":
+			jsonSchema.type = "array";
+			jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
+			break;
+		case "tuple":
+		case "tuple_with_rest":
+		case "loose_tuple":
+		case "strict_tuple":
+			jsonSchema.type = "array";
+			if (config?.target === "openapi-3.0") {
+				jsonSchema.items = { anyOf: [] };
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.items.anyOf.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.items.anyOf.push(convertSchema({}, valibotSchema.rest, config, context));
+				else if (valibotSchema.type === "strict_tuple" || valibotSchema.type === "tuple") jsonSchema.maxItems = valibotSchema.items.length;
+			} else if (config?.target === "draft-2020-12") {
+				jsonSchema.prefixItems = [];
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.prefixItems.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.items = convertSchema({}, valibotSchema.rest, config, context);
+				else if (valibotSchema.type === "strict_tuple") jsonSchema.items = false;
+			} else {
+				jsonSchema.items = [];
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
+				else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
+			}
+			break;
+		case "object":
+		case "object_with_rest":
+		case "loose_object":
+		case "strict_object":
+			jsonSchema.type = "object";
+			jsonSchema.properties = {};
+			jsonSchema.required = [];
+			for (const key in valibotSchema.entries) {
+				const entry = valibotSchema.entries[key];
+				jsonSchema.properties[key] = convertSchema({}, entry, config, context);
+				if (entry.type !== "exact_optional" && entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
+			}
+			if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
+			else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
+			break;
+		case "record":
+			if (config?.target === "openapi-3.0" && "pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
+			if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
+			jsonSchema.type = "object";
+			if (config?.target !== "openapi-3.0") jsonSchema.propertyNames = convertSchema({}, valibotSchema.key, config, context);
+			jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
+			break;
+		case "any":
+		case "unknown": break;
+		case "never":
+			jsonSchema.not = {};
+			break;
+		case "nullable":
+		case "nullish":
+			if (config?.target === "openapi-3.0") {
+				const innerSchema = convertSchema({}, valibotSchema.wrapped, config, context);
+				Object.assign(jsonSchema, innerSchema);
+				jsonSchema.nullable = true;
+			} else jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
+			if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
+			break;
+		case "exact_optional":
+		case "optional":
+		case "undefinedable":
+			jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
+			if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
+			break;
+		case "literal":
+			if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotSchema.literal];
+			else jsonSchema.const = valibotSchema.literal;
+			break;
+		case "enum":
+			jsonSchema.enum = valibotSchema.options;
+			if (valibotSchema.options.every((option) => typeof option === "string")) jsonSchema.type = "string";
+			else if (valibotSchema.options.every((option) => typeof option === "number")) jsonSchema.type = "number";
+			else if (config?.target !== "openapi-3.0") jsonSchema.type = ["string", "number"];
+			break;
+		case "picklist": {
+			const hasInvalidOption = valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string");
+			if (hasInvalidOption) errors = addError(errors, "An option of the \"picklist\" schema is not JSON compatible.");
+			jsonSchema.enum = valibotSchema.options;
+			if (valibotSchema.options.every((option) => typeof option === "string")) jsonSchema.type = "string";
+			else if (valibotSchema.options.every((option) => typeof option === "number")) jsonSchema.type = "number";
+			else if (!hasInvalidOption && config?.target !== "openapi-3.0") jsonSchema.type = ["string", "number"];
+			break;
+		}
+		case "union":
+			jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "variant":
+			jsonSchema.oneOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "intersect":
+			jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "lazy": {
+			let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
+			if (!wrappedValibotSchema) {
+				wrappedValibotSchema = valibotSchema.getter(void 0);
+				context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
+			}
+			let referenceId = context.referenceMap.get(wrappedValibotSchema);
+			if (!referenceId) {
+				referenceId = `${refCount++}`;
+				context.referenceMap.set(wrappedValibotSchema, referenceId);
+				context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
+			}
+			jsonSchema.$ref = getDefinitionRef(referenceId);
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema: wrappedValibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			break;
+		}
+		default: errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideSchema) {
+		const schemaOverride = config.overrideSchema({
+			...context,
+			referenceId: context.referenceMap.get(valibotSchema),
+			valibotSchema,
+			jsonSchema,
+			errors
+		});
+		if (schemaOverride) return { ...schemaOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+let store;
+/**
+* Adds new definitions to the global schema definitions.
+*
+* @param definitions The schema definitions.
+*
+* @beta
+*/
+function addGlobalDefs(definitions) {
+	store = {
+		...store ?? {},
+		...definitions
+	};
+}
+/**
+* Returns the current global schema definitions.
+*
+* @returns The schema definitions.
+*
+* @beta
+*/
+function getGlobalDefs() {
+	return store;
+}
+/**
+* Converts a Valibot schema to the JSON Schema format.
+*
+* @param schema The Valibot schema object.
+* @param config The JSON Schema configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function toJsonSchema(schema, config) {
+	const context = {
+		definitions: {},
+		referenceMap: /* @__PURE__ */ new Map(),
+		getterMap: /* @__PURE__ */ new Map()
+	};
+	const definitions = config?.definitions ?? getGlobalDefs();
+	if (definitions) {
+		for (const key in definitions) context.referenceMap.set(definitions[key], key);
+		for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+	}
+	const jsonSchema = convertSchema({}, schema, config, context);
+	const target = config?.target ?? "draft-07";
+	if (target === "draft-2020-12") jsonSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
+	else if (target === "draft-07") jsonSchema.$schema = "http://json-schema.org/draft-07/schema#";
+	if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
+	return jsonSchema;
+}
+/**
+* Converts Valibot schema definitions to JSON Schema definitions.
+*
+* @param definitions The Valibot schema definitions.
+* @param config The JSON Schema configuration.
+*
+* @returns The converted JSON Schema definitions.
+*/
+function toJsonSchemaDefs(definitions, config) {
+	const context = {
+		definitions: {},
+		referenceMap: /* @__PURE__ */ new Map(),
+		getterMap: /* @__PURE__ */ new Map()
+	};
+	for (const key in definitions) context.referenceMap.set(definitions[key], key);
+	for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+	return context.definitions;
+}
+const SUPPORTED_TARGETS = [
+	"draft-07",
+	"draft-2020-12",
+	"openapi-3.0"
+];
+/**
+* Converts a Valibot schema to the Standard JSON Schema format.
+*
+* @param schema The Valibot schema object.
+*
+* @returns The Standard JSON Schema.
+*/
+function toStandardJsonSchema(schema) {
+	return { "~standard": {
+		...schema["~standard"],
+		jsonSchema: {
+			input(options) {
+				if (SUPPORTED_TARGETS.includes(options.target)) return toJsonSchema(schema, {
+					typeMode: "input",
+					target: options.target,
+					...options.libraryOptions
+				});
+				throw new Error(`Unsupported target: ${options.target}`);
+			},
+			output(options) {
+				if (SUPPORTED_TARGETS.includes(options.target)) return toJsonSchema(schema, {
+					typeMode: "output",
+					target: options.target,
+					...options.libraryOptions
+				});
+				throw new Error(`Unsupported target: ${options.target}`);
+			}
+		}
+	} };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@xsai+shared@0.5.0-beta.7/node_modules/@xsai/shared/dist/index.js
+var XSAIError = class extends Error {
+	constructor(message, code, options = {}) {
+		super(message, { cause: options.cause });
+		this.code = code;
+		this.name = new.target.name;
+	}
+	static isInstance(error) {
+		return error instanceof this;
+	}
+};
+var APICallError = class extends XSAIError {
+	constructor(message, options) {
+		super(message, "api_call_error", options);
+		this.requestBody = options.requestBody;
+		this.response = options.response;
+		this.responseBody = options.responseBody;
+		this.responseHeaders = Object.fromEntries(options.response.headers.entries());
+		this.statusCode = options.response.status;
+		this.statusText = options.response.statusText;
+		this.url = options.response.url;
+	}
+};
+var InvalidResponseError = class extends XSAIError {
+	constructor(message, options) {
+		super(message, "invalid_response", options);
+		Object.assign(this, options);
+	}
+};
+var InvalidToolCallError = class extends XSAIError {
+	constructor(message, options) {
+		super(message, "invalid_tool_call", options);
+		Object.assign(this, options);
+	}
+};
+var InvalidToolInputError = class extends XSAIError {
+	constructor(message, options) {
+		super(message, "invalid_tool_input", options);
+		Object.assign(this, options);
+	}
+};
+var JSONParseError = class extends XSAIError {
+	constructor(message, options) {
+		super(message, "json_parse_error", options);
+		this.text = options.text;
+	}
+};
+var ToolExecutionError = class extends XSAIError {
+	constructor(message, options) {
+		super(message, "tool_execution_error", options);
+		Object.assign(this, options);
+	}
+};
+const strCamelToSnake = (str) => str.replace(/[A-Z]/g, (s) => `_${s.toLowerCase()}`);
+const objCamelToSnake = (obj) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [strCamelToSnake(k), v]));
+const clean = (obj) => Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+const requestBody = (body) => JSON.stringify(objCamelToSnake(clean({
+	...body,
+	abortSignal: void 0,
+	apiKey: void 0,
+	baseURL: void 0,
+	fetch: void 0,
+	headers: void 0
+})));
+const requestHeaders = (headers, apiKey) => clean({
+	Authorization: apiKey !== void 0 ? `Bearer ${apiKey}` : void 0,
+	...headers
+});
+const requestURL = (path, baseURL) => {
+	const base = baseURL.toString();
+	return new URL(path, base.endsWith("/") ? base : `${base}/`);
+};
+const responseCatch = async (res) => {
+	if (!res.ok) {
+		const responseBody = await res.text();
+		throw new APICallError(`Remote sent ${res.status} response: ${responseBody}`, {
+			response: res,
+			responseBody
+		});
+	}
+	if (!res.body) throw new InvalidResponseError("Response body is empty from remote server", {
+		reason: "empty_body",
+		response: res
+	});
+	if (!(res.body instanceof ReadableStream)) {
+		const contentType = res.headers.get("Content-Type");
+		throw new InvalidResponseError(`Expected Response body to be a ReadableStream, but got ${String(res.body)}; Content Type is ${contentType}`, {
+			body: res.body,
+			contentType,
+			reason: "invalid_body",
+			response: res
+		});
+	}
+	return res;
+};
+const postJSON = async (path, options) => (options.fetch ?? globalThis.fetch)(requestURL(path, options.baseURL), {
+	body: requestBody(options),
+	headers: requestHeaders({
+		"Content-Type": "application/json",
+		...options.headers
+	}, options.apiKey),
+	method: "POST",
+	signal: options.abortSignal
+}).then(responseCatch);
+const responseJSON = async (res) => {
+	const text = await res.text();
+	try {
+		return JSON.parse(text);
+	} catch (cause) {
+		throw new JSONParseError(`Failed to parse response, response body: ${text}`, {
+			cause,
+			text
+		});
+	}
+};
+const trampoline = async (fn) => {
+	let result = await fn();
+	while (result instanceof Function) result = await result();
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@xsai+shared-chat@0.5.0-beta.7/node_modules/@xsai/shared-chat/dist/index.js
+const chat = async (options) => postJSON("chat/completions", {
+	...options,
+	maxSteps: void 0,
+	onEvent: void 0,
+	onFinish: void 0,
+	onStepFinish: void 0,
+	postToolCall: void 0,
+	prepareStep: void 0,
+	preToolCall: void 0,
+	stopWhen: void 0,
+	tools: options.tools?.map(({ execute: _execute, ...tool }) => tool)
+});
+const toToolMessageContent = (result) => {
+	if (typeof result === "string") return result;
+	if (Array.isArray(result)) {
+		if (result.every((item) => item !== null && typeof item === "object" && "type" in item && [
+			"file",
+			"image_url",
+			"input_audio",
+			"text"
+		].includes(item.type))) return result;
+	}
+	return JSON.stringify(result);
+};
+const isAbortError = (error, abortSignal) => abortSignal?.aborted === true && error === abortSignal.reason || error instanceof Error && error.name === "AbortError";
+const parseToolInput = async (tool, input) => {
+	let result;
+	try {
+		result = JSON.parse(input.trim() || "{}");
+	} catch (cause) {
+		throw new InvalidToolInputError(`Failed to parse tool input for "${tool.function.name}".`, {
+			cause,
+			toolInput: input,
+			toolName: tool.function.name
+		});
+	}
+	if (tool.validate) {
+		const validated = await tool.validate(result);
+		if (validated.issues) throw new InvalidToolInputError(`Tool input validation failed for "${tool.function.name}".`, {
+			cause: validated.issues,
+			toolInput: result,
+			toolName: tool.function.name
+		});
+		result = validated.value;
+	}
+	return result;
+};
+const runTool = async (tool, options) => {
+	try {
+		return await tool.execute(options.args, options.toolExecuteOptions);
+	} catch (cause) {
+		if (isAbortError(cause, options.toolExecuteOptions.abortSignal)) throw cause;
+		throw new ToolExecutionError(`Tool "${tool.function.name}" execution failed.`, {
+			cause,
+			toolCallId: options.toolExecuteOptions.toolCallId,
+			toolInput: options.args,
+			toolName: tool.function.name
+		});
+	}
+};
+const assertSameToolCallId = (source, next, label) => {
+	if (source === next.toolCallId) return;
+	throw new InvalidToolCallError(`${label} must preserve toolCallId "${source}".`, {
+		reason: "tool_call_id_mismatch",
+		toolCall: next
+	});
+};
+const findTool = (tools, toolName, toolCall) => {
+	const tool = tools?.find((tool2) => tool2.function.name === toolName);
+	if (!tool) {
+		const availableTools = tools?.map((tool2) => tool2.function.name);
+		throw new InvalidToolCallError(`Model tried to call unavailable tool "${toolName}", ${availableTools == null || availableTools.length === 0 ? "No tools are available" : `Available tools: ${availableTools.join(", ")}`}.`, {
+			availableTools,
+			reason: "unknown_tool",
+			toolCall,
+			toolName
+		});
+	}
+	return tool;
+};
+const executeTool = async ({ abortSignal, messages, postToolCall, preToolCall, toolCall, tools, wrapResult }) => {
+	const wrap = wrapResult ?? toToolMessageContent;
+	const toolName = toolCall.function.name;
+	const toolArguments = toolCall.function.arguments;
+	if (toolName == null) throw new InvalidToolCallError(`Missing toolCall.function.name: ${JSON.stringify(toolCall)}`, {
+		reason: "missing_name",
+		toolCall
+	});
+	if (toolArguments == null) throw new InvalidToolCallError(`Missing toolCall.function.arguments: ${JSON.stringify(toolCall)}`, {
+		reason: "missing_arguments",
+		toolCall
+	});
+	const toolExecuteOptions = {
+		abortSignal,
+		messages,
+		toolCallId: toolCall.id
+	};
+	let completionToolCall = {
+		args: toolArguments,
+		toolCallId: toolCall.id,
+		toolCallType: "function",
+		toolName
+	};
+	let completionToolResult;
+	const preToolCallResult = await preToolCall?.(completionToolCall, toolExecuteOptions);
+	if (preToolCallResult) {
+		assertSameToolCallId(completionToolCall.toolCallId, preToolCallResult, "preToolCallResult");
+		if ("result" in preToolCallResult) completionToolResult = preToolCallResult;
+		else completionToolCall = preToolCallResult;
+	}
+	if (completionToolResult == null) {
+		const tool = findTool(tools, completionToolCall.toolName, completionToolCall);
+		const args = await parseToolInput(tool, completionToolCall.args);
+		completionToolResult = {
+			args,
+			result: await runTool(tool, {
+				args,
+				toolExecuteOptions
+			}),
+			toolCallId: completionToolCall.toolCallId,
+			toolName: completionToolCall.toolName
+		};
+	}
+	const postToolCallResult = await postToolCall?.(completionToolResult, toolExecuteOptions);
+	if (postToolCallResult) {
+		assertSameToolCallId(completionToolResult.toolCallId, postToolCallResult, "postToolCallResult");
+		completionToolResult = postToolCallResult;
+	}
+	return {
+		completionToolCall,
+		completionToolResult,
+		result: wrap(completionToolResult.result)
+	};
+};
+const resolvePrepareStep = async ({ input, model, prepareStep, stepNumber, steps, toolChoice }) => {
+	const prepared = prepareStep == null ? void 0 : await prepareStep({
+		input: structuredClone(input),
+		model,
+		stepNumber,
+		steps: structuredClone(steps)
+	});
+	return {
+		input: prepared?.input != null ? structuredClone(prepared.input) : input,
+		model: prepared?.model ?? model,
+		toolChoice: prepared?.toolChoice ?? toolChoice
+	};
+};
+const stepCountAtLeast = (count) => ({ steps }) => steps.length >= count;
+const shouldStop = (stopWhen, context) => stopWhen(context);
+const computeTotalUsage = (totalUsage, usage) => totalUsage == null ? usage : {
+	inputTokens: totalUsage.inputTokens + usage.inputTokens,
+	outputTokens: totalUsage.outputTokens + usage.outputTokens,
+	totalTokens: totalUsage.totalTokens + usage.totalTokens
+};
+const normalizeChatCompletionUsage = (usage) => ({
+	inputTokens: usage.prompt_tokens,
+	outputTokens: usage.completion_tokens,
+	totalTokens: usage.total_tokens
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@xsai+generate-text@0.5.0-beta.7/node_modules/@xsai/generate-text/dist/index.js
+const rawGenerateText = async (options) => {
+	const messages = options.steps == null ? structuredClone(options.messages) : options.messages;
+	const steps = options.steps ?? [];
+	const stepOptions = await resolvePrepareStep({
+		input: messages,
+		model: options.model,
+		prepareStep: options.prepareStep,
+		stepNumber: steps.length,
+		steps,
+		toolChoice: options.toolChoice
+	});
+	return chat({
+		...options,
+		messages: stepOptions.input,
+		model: stepOptions.model,
+		steps: void 0,
+		stream: false,
+		toolChoice: stepOptions.toolChoice,
+		totalUsage: void 0
+	}).then(responseJSON).then(async (res) => {
+		const { choices } = res;
+		const usage = normalizeChatCompletionUsage(res.usage);
+		const totalUsage = computeTotalUsage(options.totalUsage, usage);
+		if (!choices?.length) {
+			const responseBody = JSON.stringify(res);
+			throw new InvalidResponseError(`No choices returned, response body: ${responseBody}`, {
+				reason: "no_choices",
+				responseBody
+			});
+		}
+		const toolCalls = [];
+		const toolResults = [];
+		const { finish_reason: finishReason, message } = choices[0];
+		const msgToolCalls = message?.tool_calls ?? [];
+		const stopWhen = options.stopWhen ?? stepCountAtLeast(1);
+		messages.push(message);
+		if (msgToolCalls.length > 0) {
+			const results = await Promise.all(msgToolCalls.map(async (toolCall) => executeTool({
+				abortSignal: options.abortSignal,
+				messages,
+				postToolCall: options.postToolCall,
+				preToolCall: options.preToolCall,
+				toolCall,
+				tools: options.tools
+			})));
+			for (const { completionToolCall, completionToolResult, result } of results) {
+				toolCalls.push(completionToolCall);
+				toolResults.push(completionToolResult);
+				messages.push({
+					content: result,
+					role: "tool",
+					tool_call_id: completionToolCall.toolCallId
+				});
+			}
+		}
+		const step = {
+			finishReason,
+			text: Array.isArray(message.content) ? message.content.filter((m) => m.type === "text").map((m) => m.text).join("\n") : message.content,
+			toolCalls,
+			toolResults,
+			usage
+		};
+		const stop = shouldStop(stopWhen, {
+			input: messages,
+			step,
+			steps: [...steps, step]
+		});
+		const willContinue = toolCalls.length > 0 && !stop;
+		steps.push(step);
+		if (options.onStepFinish) await options.onStepFinish(step);
+		if (!willContinue) return {
+			finishReason: step.finishReason,
+			messages,
+			reasoningText: message.reasoning ?? message.reasoning_content,
+			steps,
+			text: step.text,
+			toolCalls: step.toolCalls,
+			toolResults: step.toolResults,
+			totalUsage,
+			usage: step.usage
+		};
+		else return async () => rawGenerateText({
+			...options,
+			messages,
+			steps,
+			totalUsage
+		});
+	});
+};
+const generateText = async (options) => trampoline(async () => rawGenerateText(options));
+//#endregion
+//#region ../../node_modules/.pnpm/@xsai+tool@0.5.0-beta.7_@valibot+to-json-schema@1.7.1_valibot@1.4.2_typescript@6.0.3____927f6822d23b3a98d537f6f3dbeccc01/node_modules/@xsai/tool/dist/index.js
+const rawTool = ({ description, execute, name, parameters, strict }) => ({
+	execute,
+	function: {
+		description,
+		name,
+		parameters: strict !== false ? strictJsonSchema(parameters) : parameters,
+		strict: strict ?? true
+	},
+	type: "function"
+});
+//#endregion
+//#region ../core/dist/structured-output.mjs
+const defaultMaxAttempts = 3;
+const defaultToolName = "reportFindings";
+var InvalidStructuredOutputError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidStructuredOutputError";
+	}
+};
+/** Standard instruction line for localized judge findings; undefined when no language is configured. */
+function formatOutputLanguageInstruction(outputLanguage) {
+	return outputLanguage ? `Write all human-readable finding messages and suggestions in this language: ${outputLanguage}.` : void 0;
+}
+/** Prefixes each line with its 1-based number so schemas can ask for "left-column line numbers". */
+function formatSourceWithLineNumbers(source) {
+	return source.split("\n").map((line, index) => `${index + 1} | ${line}`).join("\n");
+}
+/**
+* Forces the model to call a single reporting tool and returns the validated
+* tool arguments, so a tool call doubles as structured output. Unlike
+* `response_format`-based structured output (xsai's `generateObject`), a
+* forced tool call works on any provider with function calling, and invalid
+* payloads are retried with validation feedback instead of failing outright.
+*/
+async function generateStructured(options) {
+	const maxAttempts = options.maxAttempts ?? defaultMaxAttempts;
+	const retryDelay = options.retryDelay ?? exponentialRetryDelay;
+	const toolName = options.toolName ?? defaultToolName;
+	const tool = rawTool({
+		description: options.toolDescription ?? /* @__PURE__ */ getDescription(options.schema),
+		execute: (input) => asRecord(input) ?? {},
+		name: toolName,
+		parameters: toolParametersFromSchema(options.schema),
+		strict: true
+	});
+	let previousError;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		options.signal?.throwIfAborted();
+		let response;
+		try {
+			response = await generateText({
+				abortSignal: options.signal,
+				baseURL: options.model.provider.endpoint,
+				headers: options.model.provider.headers,
+				messages: options.createMessages(previousError ? retryFeedbackFrom(toolName, previousError) : void 0),
+				model: options.model.id,
+				parallelToolCalls: false,
+				temperature: options.temperature ?? 0,
+				toolChoice: {
+					function: { name: toolName },
+					type: "function"
+				},
+				tools: [tool]
+			});
+		} catch (error) {
+			options.signal?.throwIfAborted();
+			const callError = `Tool call failed before validation: ${errorMessageFrom(error) ?? String(error)}`;
+			previousError = isRetriableHttpError(error) ? void 0 : callError;
+			options.logger?.debug(`${options.operation} attempt ${attempt} failed while calling the model: ${callError}`);
+			if (!isRetriableCallError(error) || attempt === maxAttempts) throw error;
+			await setTimeout(retryDelay(attempt), void 0, { signal: options.signal });
+			continue;
+		}
+		recordAttemptUsage(options, response);
+		const result = parseStructuredResponse(options.schema, toolName, response);
+		if (result.ok) return result.value;
+		previousError = result.error;
+		options.logger?.debug(`${options.operation} attempt ${attempt} returned an invalid structured result: ${previousError}`);
+		if (!result.retriable || attempt === maxAttempts) throw new InvalidStructuredOutputError(`Invalid structured model response: ${previousError}`);
+		await setTimeout(retryDelay(attempt), void 0, { signal: options.signal });
+	}
+	throw new InvalidStructuredOutputError("Model did not return a valid structured result");
+}
+function normalizeToolJsonSchema(schema) {
+	const normalized = normalizeJsonSchemaDefinition(schema);
+	return typeof normalized === "boolean" ? {} : normalized;
+}
+/** Converts a valibot schema into provider-compliant strict tool parameters. */
+function toolParametersFromSchema(schema) {
+	return normalizeToolJsonSchema(toJsonSchema(schema));
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function exponentialRetryDelay(attempt) {
+	return 500 * 2 ** (attempt - 1);
+}
+function isRetriableCallError(error) {
+	if (!(error instanceof Error)) return true;
+	if (isRetriableHttpError(error)) return true;
+	return error.name === "InvalidToolCallError" || error.name === "InvalidToolInputError" || error.name === "ToolExecutionError";
+}
+function isRetriableHttpError(error) {
+	if (!(error instanceof Error)) return false;
+	const statusCode = "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : void 0;
+	return statusCode !== void 0 && (statusCode >= 500 || [408, 429].includes(statusCode));
+}
+function normalizeJsonSchemaDefinition(schema) {
+	if (typeof schema === "boolean") return schema;
+	const normalized = { ...schema };
+	delete normalized.$schema;
+	if (normalized.type === "object") normalized.additionalProperties = false;
+	if (normalized.properties) {
+		normalized.properties = Object.fromEntries(Object.entries(normalized.properties).map(([key, propertySchema]) => [key, normalizeJsonSchemaDefinition(propertySchema)]));
+		normalized.required = Object.keys(normalized.properties);
+	}
+	if (normalized.items) normalized.items = Array.isArray(normalized.items) ? normalized.items.map((item) => normalizeJsonSchemaDefinition(item)) : normalizeJsonSchemaDefinition(normalized.items);
+	if (normalized.$defs) normalized.$defs = normalizeJsonSchemaMap(normalized.$defs);
+	if (normalized.definitions) normalized.definitions = normalizeJsonSchemaMap(normalized.definitions);
+	for (const key of [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	]) if (normalized[key]) normalized[key] = normalized[key].map((item) => normalizeJsonSchemaDefinition(item));
+	if (normalized.not) normalized.not = normalizeJsonSchemaDefinition(normalized.not);
+	return normalized;
+}
+function normalizeJsonSchemaMap(map) {
+	return Object.fromEntries(Object.entries(map).map(([key, schema]) => [key, normalizeJsonSchemaDefinition(schema)]));
+}
+function normalizeUsage(usage) {
+	const record = asRecord(usage);
+	if (!record) return;
+	const normalized = {
+		inputTokens: numberFromRecord(record, "inputTokens") ?? numberFromRecord(record, "input_tokens") ?? numberFromRecord(record, "prompt_tokens"),
+		outputTokens: numberFromRecord(record, "outputTokens") ?? numberFromRecord(record, "output_tokens") ?? numberFromRecord(record, "completion_tokens"),
+		totalTokens: numberFromRecord(record, "totalTokens") ?? numberFromRecord(record, "total_tokens")
+	};
+	return Object.values(normalized).some((value) => value !== void 0) ? normalized : void 0;
+}
+function numberFromRecord(record, key) {
+	const value = record[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseStructuredResponse(schema, toolName, response) {
+	if (response.finishReason === "content_filter") return {
+		error: `${toolName} was not returned because the model finished with content_filter`,
+		ok: false,
+		retriable: false
+	};
+	if (response.finishReason === "length") return {
+		error: `${toolName} was not returned completely because the model finished with length`,
+		ok: false,
+		retriable: true
+	};
+	const toolResults = response.toolResults.filter((result) => result.toolName === toolName);
+	if (toolResults.length === 0) return {
+		error: `Missing ${toolName} tool result; finishReason=${response.finishReason}`,
+		ok: false,
+		retriable: true
+	};
+	if (toolResults.length > 1) return {
+		error: `Expected one ${toolName} tool result, received ${toolResults.length}`,
+		ok: false,
+		retriable: true
+	};
+	try {
+		return {
+			ok: true,
+			value: parse(schema, toolResults[0].result)
+		};
+	} catch (error) {
+		return {
+			error: errorMessageFrom(error) ?? String(error),
+			ok: false,
+			retriable: true
+		};
+	}
+}
+function recordAttemptUsage(options, response) {
+	const usage = normalizeUsage(response.usage);
+	if (!options.metering || !usage) return;
+	options.metering.recordUsage({
+		inputTokens: usage.inputTokens,
+		metadata: { operation: options.operation },
+		modelId: options.model.id,
+		outputTokens: usage.outputTokens,
+		providerId: options.model.provider.id,
+		totalTokens: usage.totalTokens
+	});
+}
+function retryFeedbackFrom(toolName, error) {
+	return [
+		"Your previous tool call could not be validated.",
+		`Validation error: ${error}`,
+		`Call ${toolName} again with arguments that exactly match the tool schema.`
+	].join("\n");
+}
+//#endregion
 //#region src/agents/judge/agent.ts
-const judgeFindingSchema = pipe(object({
-	confidence: pipe(picklist([
+const judgeFindingSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ object({
+	confidence: /* @__PURE__ */ pipe(/* @__PURE__ */ picklist([
 		"high",
 		"medium",
 		"low"
-	]), description("Confidence in this finding. Use exactly \"low\", \"medium\", or \"high\" without punctuation.")),
-	line: pipe(number(), description([
+	]), /* @__PURE__ */ description("Confidence in this finding. Use exactly \"low\", \"medium\", or \"high\" without punctuation.")),
+	line: /* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ description([
 		"Use the declaration line of the specific symbol being reported.",
 		"Use the left-column line number from the numbered code block.",
 		"Do not use a nearby caller line unless that caller is the symbol being reported."
 	].join(" "))),
-	message: pipe(string(), description([
+	message: /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ description([
 		"Mention the specific symbol being reported.",
 		"Explain the rule-specific design or readability smell.",
 		"Do not list unrelated symbol names in the message.",
 		"Keep the message short."
 	].join(" "))),
-	suggestion: pipe(string(), description([
+	suggestion: /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ description([
 		"Provide one concrete remediation direction.",
 		"Do not propose a code patch.",
 		"Keep the suggestion under 35 words."
 	].join(" ")))
-}), description("One warning-level report for a rule-specific design or readability smell."));
-const judgeResponseSchema = pipe(object({ findings: pipe(array(judgeFindingSchema), description("All warning-level findings. Return an empty array when there is no qualifying issue for the current rule.")) }), description("Report findings for this TypeScript file."));
+}), /* @__PURE__ */ description("One warning-level report for a rule-specific design or readability smell."));
+const judgeResponseSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ object({ findings: /* @__PURE__ */ pipe(/* @__PURE__ */ array(judgeFindingSchema), /* @__PURE__ */ description("All warning-level findings. Return an empty array when there is no qualifying issue for the current rule.")) }), /* @__PURE__ */ description("Report findings for this TypeScript file."));
 function createJudgeMessages(source, retryFeedback, outputLanguage, prompt) {
 	return [
 		{
@@ -309,8 +1968,8 @@ function createRedundantBindingVerificationPrompt(candidates) {
 		"</discovery-data>"
 	].join("\n");
 }
-const verificationResponseSchema = pipe(object({ decisions: pipe(array(object({
-	boundary: pipe(picklist([
+const verificationResponseSchema = /* @__PURE__ */ pipe(/* @__PURE__ */ object({ decisions: /* @__PURE__ */ pipe(/* @__PURE__ */ array(/* @__PURE__ */ object({
+	boundary: /* @__PURE__ */ pipe(/* @__PURE__ */ picklist([
 		"none",
 		"snapshot-or-restoration",
 		"receiver",
@@ -319,24 +1978,24 @@ const verificationResponseSchema = pipe(object({ decisions: pipe(array(object({
 		"mutable-work-state",
 		"type-or-domain",
 		"uncertain"
-	]), description("The concrete semantic boundary, or \"none\" only when no boundary exists.")),
-	confidence: pipe(picklist([
+	]), /* @__PURE__ */ description("The concrete semantic boundary, or \"none\" only when no boundary exists.")),
+	confidence: /* @__PURE__ */ pipe(/* @__PURE__ */ picklist([
 		"high",
 		"medium",
 		"low"
-	]), description("Confidence in this verification decision.")),
-	initializer: pipe(picklist([
+	]), /* @__PURE__ */ description("Confidence in this verification decision.")),
+	initializer: /* @__PURE__ */ pipe(/* @__PURE__ */ picklist([
 		"identifier",
 		"static-member-access",
 		"indexed-or-dynamic",
 		"computed-or-constructed",
 		"uncertain"
-	]), description("Classify the complete initializer. Bracket access belongs to \"indexed-or-dynamic\", never \"static-member-access\".")),
-	line: pipe(number(), description("One candidate declaration line supplied by discovery. Never add another line.")),
-	message: pipe(string(), description("Explain why the candidate qualifies or which exclusion rejects it.")),
-	safeSubstitution: pipe(boolean(), description("True only when every use can be replaced by the exact initializer without semantic change.")),
-	suggestion: pipe(string(), description("For accepted candidates, give a direct-use remediation under 35 words; otherwise briefly state the preserved boundary."))
-})), description("One verification decision per supplied candidate line. Omit no candidate and add no line.")) }), description("Strict verification decisions for discovered rebinding candidates."));
+	]), /* @__PURE__ */ description("Classify the complete initializer. Bracket access belongs to \"indexed-or-dynamic\", never \"static-member-access\".")),
+	line: /* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ description("One candidate declaration line supplied by discovery. Never add another line.")),
+	message: /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ description("Explain why the candidate qualifies or which exclusion rejects it.")),
+	safeSubstitution: /* @__PURE__ */ pipe(/* @__PURE__ */ boolean(), /* @__PURE__ */ description("True only when every use can be replaced by the exact initializer without semantic change.")),
+	suggestion: /* @__PURE__ */ pipe(/* @__PURE__ */ string(), /* @__PURE__ */ description("For accepted candidates, give a direct-use remediation under 35 words; otherwise briefly state the preserved boundary."))
+})), /* @__PURE__ */ description("One verification decision per supplied candidate line. Omit no candidate and add no line.")) }), /* @__PURE__ */ description("Strict verification decisions for discovered rebinding candidates."));
 function acceptedVerificationDecisions(decisions) {
 	return decisions.filter((decision) => (decision.initializer === "identifier" || decision.initializer === "static-member-access") && decision.boundary === "none" && decision.safeSubstitution).map((decision) => ({
 		confidence: decision.confidence,
@@ -654,4 +2313,4 @@ const examplePlugin = definePlugin({
 	}
 });
 //#endregion
-export { createJudgeMessages, createReportFindingsToolParameters, examplePlugin as default, examplePlugin, inlineMiniatureNormalizerPrompt, inlineMiniatureNormalizerRule, judgeFindingSchema, judgeResponseSchema, privateSchemaToolkitPrompt, privateSchemaToolkitRule, redundantBindingPrompt, redundantBindingRule, redundantJsdocPrompt, redundantJsdocRule, trivialWrapperStackPrompt, trivialWrapperStackRule, vacuousFunctionPrompt, vacuousFunctionRule };
+export { createJudgeMessages, createReportFindingsToolParameters, examplePlugin as default, examplePlugin, inlineMiniatureNormalizerPrompt, inlineMiniatureNormalizerRule, judgeFindingSchema, judgeResponseSchema, privateSchemaToolkitPrompt, privateSchemaToolkitRule, redundantBindingPrompt, redundantBindingRule, redundantJsdocPrompt, redundantJsdocRule, dist_exports as t, trivialWrapperStackPrompt, trivialWrapperStackRule, vacuousFunctionPrompt, vacuousFunctionRule };