import { __commonJS, __export, __toESM } from "./chunk-Dx39-ABv.mjs";
import crypto from "node:crypto";

//#region node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/regex.js
var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;

//#endregion
//#region node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/validate.js
function validate$1(uuid) {
	return typeof uuid === "string" && regex_default.test(uuid);
}
var validate_default = validate$1;

//#endregion
//#region node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/stringify.js
/**
* Convert array of 16 byte values to UUID string format of the form:
* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
*/
const byteToHex = [];
for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
function unsafeStringify(arr$1, offset = 0) {
	return (byteToHex[arr$1[offset + 0]] + byteToHex[arr$1[offset + 1]] + byteToHex[arr$1[offset + 2]] + byteToHex[arr$1[offset + 3]] + "-" + byteToHex[arr$1[offset + 4]] + byteToHex[arr$1[offset + 5]] + "-" + byteToHex[arr$1[offset + 6]] + byteToHex[arr$1[offset + 7]] + "-" + byteToHex[arr$1[offset + 8]] + byteToHex[arr$1[offset + 9]] + "-" + byteToHex[arr$1[offset + 10]] + byteToHex[arr$1[offset + 11]] + byteToHex[arr$1[offset + 12]] + byteToHex[arr$1[offset + 13]] + byteToHex[arr$1[offset + 14]] + byteToHex[arr$1[offset + 15]]).toLowerCase();
}

//#endregion
//#region node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/rng.js
const rnds8Pool = new Uint8Array(256);
let poolPtr = rnds8Pool.length;
function rng() {
	if (poolPtr > rnds8Pool.length - 16) {
		crypto.randomFillSync(rnds8Pool);
		poolPtr = 0;
	}
	return rnds8Pool.slice(poolPtr, poolPtr += 16);
}

//#endregion
//#region node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/native.js
var native_default = { randomUUID: crypto.randomUUID };

//#endregion
//#region node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v4.js
function v4(options, buf, offset) {
	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
	options = options || {};
	const rnds = options.random || (options.rng || rng)();
	rnds[6] = rnds[6] & 15 | 64;
	rnds[8] = rnds[8] & 63 | 128;
	if (buf) {
		offset = offset || 0;
		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
		return buf;
	}
	return unsafeStringify(rnds);
}
var v4_default = v4;

//#endregion
//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
var require_retry_operation = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
	function RetryOperation$1(timeouts, options) {
		if (typeof options === "boolean") options = { forever: options };
		this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
		this._timeouts = timeouts;
		this._options = options || {};
		this._maxRetryTime = options && options.maxRetryTime || Infinity;
		this._fn = null;
		this._errors = [];
		this._attempts = 1;
		this._operationTimeout = null;
		this._operationTimeoutCb = null;
		this._timeout = null;
		this._operationStart = null;
		this._timer = null;
		if (this._options.forever) this._cachedTimeouts = this._timeouts.slice(0);
	}
	module.exports = RetryOperation$1;
	RetryOperation$1.prototype.reset = function() {
		this._attempts = 1;
		this._timeouts = this._originalTimeouts.slice(0);
	};
	RetryOperation$1.prototype.stop = function() {
		if (this._timeout) clearTimeout(this._timeout);
		if (this._timer) clearTimeout(this._timer);
		this._timeouts = [];
		this._cachedTimeouts = null;
	};
	RetryOperation$1.prototype.retry = function(err) {
		if (this._timeout) clearTimeout(this._timeout);
		if (!err) return false;
		var currentTime = (/* @__PURE__ */ new Date()).getTime();
		if (err && currentTime - this._operationStart >= this._maxRetryTime) {
			this._errors.push(err);
			this._errors.unshift(new Error("RetryOperation timeout occurred"));
			return false;
		}
		this._errors.push(err);
		var timeout = this._timeouts.shift();
		if (timeout === void 0) if (this._cachedTimeouts) {
			this._errors.splice(0, this._errors.length - 1);
			timeout = this._cachedTimeouts.slice(-1);
		} else return false;
		var self = this;
		this._timer = setTimeout(function() {
			self._attempts++;
			if (self._operationTimeoutCb) {
				self._timeout = setTimeout(function() {
					self._operationTimeoutCb(self._attempts);
				}, self._operationTimeout);
				if (self._options.unref) self._timeout.unref();
			}
			self._fn(self._attempts);
		}, timeout);
		if (this._options.unref) this._timer.unref();
		return true;
	};
	RetryOperation$1.prototype.attempt = function(fn, timeoutOps) {
		this._fn = fn;
		if (timeoutOps) {
			if (timeoutOps.timeout) this._operationTimeout = timeoutOps.timeout;
			if (timeoutOps.cb) this._operationTimeoutCb = timeoutOps.cb;
		}
		var self = this;
		if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
			self._operationTimeoutCb();
		}, self._operationTimeout);
		this._operationStart = (/* @__PURE__ */ new Date()).getTime();
		this._fn(this._attempts);
	};
	RetryOperation$1.prototype.try = function(fn) {
		console.log("Using RetryOperation.try() is deprecated");
		this.attempt(fn);
	};
	RetryOperation$1.prototype.start = function(fn) {
		console.log("Using RetryOperation.start() is deprecated");
		this.attempt(fn);
	};
	RetryOperation$1.prototype.start = RetryOperation$1.prototype.try;
	RetryOperation$1.prototype.errors = function() {
		return this._errors;
	};
	RetryOperation$1.prototype.attempts = function() {
		return this._attempts;
	};
	RetryOperation$1.prototype.mainError = function() {
		if (this._errors.length === 0) return null;
		var counts = {};
		var mainError = null;
		var mainErrorCount = 0;
		for (var i = 0; i < this._errors.length; i++) {
			var error = this._errors[i];
			var message = error.message;
			var count = (counts[message] || 0) + 1;
			counts[message] = count;
			if (count >= mainErrorCount) {
				mainError = error;
				mainErrorCount = count;
			}
		}
		return mainError;
	};
} });

//#endregion
//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
var require_retry$1 = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
	var RetryOperation = require_retry_operation();
	exports.operation = function(options) {
		var timeouts = exports.timeouts(options);
		return new RetryOperation(timeouts, {
			forever: options && (options.forever || options.retries === Infinity),
			unref: options && options.unref,
			maxRetryTime: options && options.maxRetryTime
		});
	};
	exports.timeouts = function(options) {
		if (options instanceof Array) return [].concat(options);
		var opts = {
			retries: 10,
			factor: 2,
			minTimeout: 1 * 1e3,
			maxTimeout: Infinity,
			randomize: false
		};
		for (var key in options) opts[key] = options[key];
		if (opts.minTimeout > opts.maxTimeout) throw new Error("minTimeout is greater than maxTimeout");
		var timeouts = [];
		for (var i = 0; i < opts.retries; i++) timeouts.push(this.createTimeout(i, opts));
		if (options && options.forever && !timeouts.length) timeouts.push(this.createTimeout(i, opts));
		timeouts.sort(function(a, b) {
			return a - b;
		});
		return timeouts;
	};
	exports.createTimeout = function(attempt, opts) {
		var random = opts.randomize ? Math.random() + 1 : 1;
		var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
		timeout = Math.min(timeout, opts.maxTimeout);
		return timeout;
	};
	exports.wrap = function(obj, options, methods) {
		if (options instanceof Array) {
			methods = options;
			options = null;
		}
		if (!methods) {
			methods = [];
			for (var key in obj) if (typeof obj[key] === "function") methods.push(key);
		}
		for (var i = 0; i < methods.length; i++) {
			var method = methods[i];
			var original = obj[method];
			obj[method] = function retryWrapper(original$1) {
				var op = exports.operation(options);
				var args = Array.prototype.slice.call(arguments, 1);
				var callback = args.pop();
				args.push(function(err) {
					if (op.retry(err)) return;
					if (err) arguments[0] = op.mainError();
					callback.apply(this, arguments);
				});
				op.attempt(function() {
					original$1.apply(obj, args);
				});
			}.bind(obj, original);
			obj[method].options = options;
		}
	};
} });

//#endregion
//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
var require_retry = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
	module.exports = require_retry$1();
} });

//#endregion
//#region node_modules/.pnpm/p-retry@4.6.2/node_modules/p-retry/index.js
var require_p_retry = __commonJS({ "node_modules/.pnpm/p-retry@4.6.2/node_modules/p-retry/index.js"(exports, module) {
	const retry = require_retry();
	const networkErrorMsgs = [
		"Failed to fetch",
		"NetworkError when attempting to fetch resource.",
		"The Internet connection appears to be offline.",
		"Network request failed"
	];
	var AbortError = class extends Error {
		constructor(message) {
			super();
			if (message instanceof Error) {
				this.originalError = message;
				({message} = message);
			} else {
				this.originalError = new Error(message);
				this.originalError.stack = this.stack;
			}
			this.name = "AbortError";
			this.message = message;
		}
	};
	const decorateErrorWithCounts = (error, attemptNumber, options) => {
		const retriesLeft = options.retries - (attemptNumber - 1);
		error.attemptNumber = attemptNumber;
		error.retriesLeft = retriesLeft;
		return error;
	};
	const isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
	const pRetry$3 = (input, options) => new Promise((resolve, reject) => {
		options = {
			onFailedAttempt: () => {},
			retries: 10,
			...options
		};
		const operation = retry.operation(options);
		operation.attempt(async (attemptNumber) => {
			try {
				resolve(await input(attemptNumber));
			} catch (error) {
				if (!(error instanceof Error)) {
					reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
					return;
				}
				if (error instanceof AbortError) {
					operation.stop();
					reject(error.originalError);
				} else if (error instanceof TypeError && !isNetworkError(error.message)) {
					operation.stop();
					reject(error);
				} else {
					decorateErrorWithCounts(error, attemptNumber, options);
					try {
						await options.onFailedAttempt(error);
					} catch (error$1) {
						reject(error$1);
						return;
					}
					if (!operation.retry(error)) reject(operation.mainError());
				}
			}
		});
	});
	module.exports = pRetry$3;
	module.exports.default = pRetry$3;
	module.exports.AbortError = AbortError;
} });

//#endregion
//#region node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js
var require_eventemitter3 = __commonJS({ "node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js"(exports, module) {
	var has = Object.prototype.hasOwnProperty, prefix = "~";
	/**
	* Constructor to create a storage for our `EE` objects.
	* An `Events` instance is a plain object whose properties are event names.
	*
	* @constructor
	* @private
	*/
	function Events() {}
	if (Object.create) {
		Events.prototype = Object.create(null);
		if (!new Events().__proto__) prefix = false;
	}
	/**
	* Representation of a single event listener.
	*
	* @param {Function} fn The listener function.
	* @param {*} context The context to invoke the listener with.
	* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
	* @constructor
	* @private
	*/
	function EE(fn, context, once) {
		this.fn = fn;
		this.context = context;
		this.once = once || false;
	}
	/**
	* Add a listener for a given event.
	*
	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
	* @param {(String|Symbol)} event The event name.
	* @param {Function} fn The listener function.
	* @param {*} context The context to invoke the listener with.
	* @param {Boolean} once Specify if the listener is a one-time listener.
	* @returns {EventEmitter}
	* @private
	*/
	function addListener(emitter, event, fn, context, once) {
		if (typeof fn !== "function") throw new TypeError("The listener must be a function");
		var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
		if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
		else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
		else emitter._events[evt] = [emitter._events[evt], listener];
		return emitter;
	}
	/**
	* Clear event by name.
	*
	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
	* @param {(String|Symbol)} evt The Event name.
	* @private
	*/
	function clearEvent(emitter, evt) {
		if (--emitter._eventsCount === 0) emitter._events = new Events();
		else delete emitter._events[evt];
	}
	/**
	* Minimal `EventEmitter` interface that is molded against the Node.js
	* `EventEmitter` interface.
	*
	* @constructor
	* @public
	*/
	function EventEmitter$1() {
		this._events = new Events();
		this._eventsCount = 0;
	}
	/**
	* Return an array listing the events for which the emitter has registered
	* listeners.
	*
	* @returns {Array}
	* @public
	*/
	EventEmitter$1.prototype.eventNames = function eventNames() {
		var names = [], events, name;
		if (this._eventsCount === 0) return names;
		for (name in events = this._events) if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
		if (Object.getOwnPropertySymbols) return names.concat(Object.getOwnPropertySymbols(events));
		return names;
	};
	/**
	* Return the listeners registered for a given event.
	*
	* @param {(String|Symbol)} event The event name.
	* @returns {Array} The registered listeners.
	* @public
	*/
	EventEmitter$1.prototype.listeners = function listeners(event) {
		var evt = prefix ? prefix + event : event, handlers = this._events[evt];
		if (!handlers) return [];
		if (handlers.fn) return [handlers.fn];
		for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) ee[i] = handlers[i].fn;
		return ee;
	};
	/**
	* Return the number of listeners listening to a given event.
	*
	* @param {(String|Symbol)} event The event name.
	* @returns {Number} The number of listeners.
	* @public
	*/
	EventEmitter$1.prototype.listenerCount = function listenerCount(event) {
		var evt = prefix ? prefix + event : event, listeners = this._events[evt];
		if (!listeners) return 0;
		if (listeners.fn) return 1;
		return listeners.length;
	};
	/**
	* Calls each of the listeners registered for a given event.
	*
	* @param {(String|Symbol)} event The event name.
	* @returns {Boolean} `true` if the event had listeners, else `false`.
	* @public
	*/
	EventEmitter$1.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
		var evt = prefix ? prefix + event : event;
		if (!this._events[evt]) return false;
		var listeners = this._events[evt], len = arguments.length, args, i;
		if (listeners.fn) {
			if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
			switch (len) {
				case 1: return listeners.fn.call(listeners.context), true;
				case 2: return listeners.fn.call(listeners.context, a1), true;
				case 3: return listeners.fn.call(listeners.context, a1, a2), true;
				case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
				case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
				case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
			}
			for (i = 1, args = new Array(len - 1); i < len; i++) args[i - 1] = arguments[i];
			listeners.fn.apply(listeners.context, args);
		} else {
			var length = listeners.length, j;
			for (i = 0; i < length; i++) {
				if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
				switch (len) {
					case 1:
						listeners[i].fn.call(listeners[i].context);
						break;
					case 2:
						listeners[i].fn.call(listeners[i].context, a1);
						break;
					case 3:
						listeners[i].fn.call(listeners[i].context, a1, a2);
						break;
					case 4:
						listeners[i].fn.call(listeners[i].context, a1, a2, a3);
						break;
					default:
						if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) args[j - 1] = arguments[j];
						listeners[i].fn.apply(listeners[i].context, args);
				}
			}
		}
		return true;
	};
	/**
	* Add a listener for a given event.
	*
	* @param {(String|Symbol)} event The event name.
	* @param {Function} fn The listener function.
	* @param {*} [context=this] The context to invoke the listener with.
	* @returns {EventEmitter} `this`.
	* @public
	*/
	EventEmitter$1.prototype.on = function on(event, fn, context) {
		return addListener(this, event, fn, context, false);
	};
	/**
	* Add a one-time listener for a given event.
	*
	* @param {(String|Symbol)} event The event name.
	* @param {Function} fn The listener function.
	* @param {*} [context=this] The context to invoke the listener with.
	* @returns {EventEmitter} `this`.
	* @public
	*/
	EventEmitter$1.prototype.once = function once(event, fn, context) {
		return addListener(this, event, fn, context, true);
	};
	/**
	* Remove the listeners of a given event.
	*
	* @param {(String|Symbol)} event The event name.
	* @param {Function} fn Only remove the listeners that match this function.
	* @param {*} context Only remove the listeners that have this context.
	* @param {Boolean} once Only remove one-time listeners.
	* @returns {EventEmitter} `this`.
	* @public
	*/
	EventEmitter$1.prototype.removeListener = function removeListener(event, fn, context, once) {
		var evt = prefix ? prefix + event : event;
		if (!this._events[evt]) return this;
		if (!fn) {
			clearEvent(this, evt);
			return this;
		}
		var listeners = this._events[evt];
		if (listeners.fn) {
			if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) clearEvent(this, evt);
		} else {
			for (var i = 0, events = [], length = listeners.length; i < length; i++) if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) events.push(listeners[i]);
			if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
			else clearEvent(this, evt);
		}
		return this;
	};
	/**
	* Remove all listeners, or those of the specified event.
	*
	* @param {(String|Symbol)} [event] The event name.
	* @returns {EventEmitter} `this`.
	* @public
	*/
	EventEmitter$1.prototype.removeAllListeners = function removeAllListeners(event) {
		var evt;
		if (event) {
			evt = prefix ? prefix + event : event;
			if (this._events[evt]) clearEvent(this, evt);
		} else {
			this._events = new Events();
			this._eventsCount = 0;
		}
		return this;
	};
	EventEmitter$1.prototype.off = EventEmitter$1.prototype.removeListener;
	EventEmitter$1.prototype.addListener = EventEmitter$1.prototype.on;
	EventEmitter$1.prefixed = prefix;
	EventEmitter$1.EventEmitter = EventEmitter$1;
	if ("undefined" !== typeof module) module.exports = EventEmitter$1;
} });

//#endregion
//#region node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js
var require_p_finally = __commonJS({ "node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js"(exports, module) {
	module.exports = (promise, onFinally) => {
		onFinally = onFinally || (() => {});
		return promise.then((val) => new Promise((resolve) => {
			resolve(onFinally());
		}).then(() => val), (err) => new Promise((resolve) => {
			resolve(onFinally());
		}).then(() => {
			throw err;
		}));
	};
} });

//#endregion
//#region node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js
var require_p_timeout = __commonJS({ "node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js"(exports, module) {
	const pFinally = require_p_finally();
	var TimeoutError = class extends Error {
		constructor(message) {
			super(message);
			this.name = "TimeoutError";
		}
	};
	const pTimeout = (promise, milliseconds, fallback) => new Promise((resolve, reject) => {
		if (typeof milliseconds !== "number" || milliseconds < 0) throw new TypeError("Expected `milliseconds` to be a positive number");
		if (milliseconds === Infinity) {
			resolve(promise);
			return;
		}
		const timer = setTimeout(() => {
			if (typeof fallback === "function") {
				try {
					resolve(fallback());
				} catch (error) {
					reject(error);
				}
				return;
			}
			const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
			const timeoutError$1 = fallback instanceof Error ? fallback : new TimeoutError(message);
			if (typeof promise.cancel === "function") promise.cancel();
			reject(timeoutError$1);
		}, milliseconds);
		pFinally(promise.then(resolve, reject), () => {
			clearTimeout(timer);
		});
	});
	module.exports = pTimeout;
	module.exports.default = pTimeout;
	module.exports.TimeoutError = TimeoutError;
} });

//#endregion
//#region node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/lower-bound.js
var require_lower_bound = __commonJS({ "node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/lower-bound.js"(exports) {
	Object.defineProperty(exports, "__esModule", { value: true });
	function lowerBound(array, value, comparator) {
		let first = 0;
		let count = array.length;
		while (count > 0) {
			const step = count / 2 | 0;
			let it = first + step;
			if (comparator(array[it], value) <= 0) {
				first = ++it;
				count -= step + 1;
			} else count = step;
		}
		return first;
	}
	exports.default = lowerBound;
} });

//#endregion
//#region node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/priority-queue.js
var require_priority_queue = __commonJS({ "node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/priority-queue.js"(exports) {
	Object.defineProperty(exports, "__esModule", { value: true });
	const lower_bound_1 = require_lower_bound();
	var PriorityQueue = class {
		constructor() {
			this._queue = [];
		}
		enqueue(run, options) {
			options = Object.assign({ priority: 0 }, options);
			const element = {
				priority: options.priority,
				run
			};
			if (this.size && this._queue[this.size - 1].priority >= options.priority) {
				this._queue.push(element);
				return;
			}
			const index = lower_bound_1.default(this._queue, element, (a, b) => b.priority - a.priority);
			this._queue.splice(index, 0, element);
		}
		dequeue() {
			const item = this._queue.shift();
			return item === null || item === void 0 ? void 0 : item.run;
		}
		filter(options) {
			return this._queue.filter((element) => element.priority === options.priority).map((element) => element.run);
		}
		get size() {
			return this._queue.length;
		}
	};
	exports.default = PriorityQueue;
} });

//#endregion
//#region node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js
var require_dist = __commonJS({ "node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js"(exports) {
	Object.defineProperty(exports, "__esModule", { value: true });
	const EventEmitter = require_eventemitter3();
	const p_timeout_1 = require_p_timeout();
	const priority_queue_1 = require_priority_queue();
	const empty = () => {};
	const timeoutError = new p_timeout_1.TimeoutError();
	/**
	Promise queue with concurrency control.
	*/
	var PQueue = class extends EventEmitter {
		constructor(options) {
			var _a, _b, _c, _d;
			super();
			this._intervalCount = 0;
			this._intervalEnd = 0;
			this._pendingCount = 0;
			this._resolveEmpty = empty;
			this._resolveIdle = empty;
			options = Object.assign({
				carryoverConcurrencyCount: false,
				intervalCap: Infinity,
				interval: 0,
				concurrency: Infinity,
				autoStart: true,
				queueClass: priority_queue_1.default
			}, options);
			if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
			if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
			this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
			this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
			this._intervalCap = options.intervalCap;
			this._interval = options.interval;
			this._queue = new options.queueClass();
			this._queueClass = options.queueClass;
			this.concurrency = options.concurrency;
			this._timeout = options.timeout;
			this._throwOnTimeout = options.throwOnTimeout === true;
			this._isPaused = options.autoStart === false;
		}
		get _doesIntervalAllowAnother() {
			return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
		}
		get _doesConcurrentAllowAnother() {
			return this._pendingCount < this._concurrency;
		}
		_next() {
			this._pendingCount--;
			this._tryToStartAnother();
			this.emit("next");
		}
		_resolvePromises() {
			this._resolveEmpty();
			this._resolveEmpty = empty;
			if (this._pendingCount === 0) {
				this._resolveIdle();
				this._resolveIdle = empty;
				this.emit("idle");
			}
		}
		_onResumeInterval() {
			this._onInterval();
			this._initializeIntervalIfNeeded();
			this._timeoutId = void 0;
		}
		_isIntervalPaused() {
			const now = Date.now();
			if (this._intervalId === void 0) {
				const delay = this._intervalEnd - now;
				if (delay < 0) this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
				else {
					if (this._timeoutId === void 0) this._timeoutId = setTimeout(() => {
						this._onResumeInterval();
					}, delay);
					return true;
				}
			}
			return false;
		}
		_tryToStartAnother() {
			if (this._queue.size === 0) {
				if (this._intervalId) clearInterval(this._intervalId);
				this._intervalId = void 0;
				this._resolvePromises();
				return false;
			}
			if (!this._isPaused) {
				const canInitializeInterval = !this._isIntervalPaused();
				if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
					const job = this._queue.dequeue();
					if (!job) return false;
					this.emit("active");
					job();
					if (canInitializeInterval) this._initializeIntervalIfNeeded();
					return true;
				}
			}
			return false;
		}
		_initializeIntervalIfNeeded() {
			if (this._isIntervalIgnored || this._intervalId !== void 0) return;
			this._intervalId = setInterval(() => {
				this._onInterval();
			}, this._interval);
			this._intervalEnd = Date.now() + this._interval;
		}
		_onInterval() {
			if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
				clearInterval(this._intervalId);
				this._intervalId = void 0;
			}
			this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
			this._processQueue();
		}
		/**
		Executes all queued functions until it reaches the limit.
		*/
		_processQueue() {
			while (this._tryToStartAnother());
		}
		get concurrency() {
			return this._concurrency;
		}
		set concurrency(newConcurrency) {
			if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
			this._concurrency = newConcurrency;
			this._processQueue();
		}
		/**
		Adds a sync or async task to the queue. Always returns a promise.
		*/
		async add(fn, options = {}) {
			return new Promise((resolve, reject) => {
				const run = async () => {
					this._pendingCount++;
					this._intervalCount++;
					try {
						const operation = this._timeout === void 0 && options.timeout === void 0 ? fn() : p_timeout_1.default(Promise.resolve(fn()), options.timeout === void 0 ? this._timeout : options.timeout, () => {
							if (options.throwOnTimeout === void 0 ? this._throwOnTimeout : options.throwOnTimeout) reject(timeoutError);
							return void 0;
						});
						resolve(await operation);
					} catch (error) {
						reject(error);
					}
					this._next();
				};
				this._queue.enqueue(run, options);
				this._tryToStartAnother();
				this.emit("add");
			});
		}
		/**
		Same as `.add()`, but accepts an array of sync or async functions.
		
		@returns A promise that resolves when all functions are resolved.
		*/
		async addAll(functions, options) {
			return Promise.all(functions.map(async (function_) => this.add(function_, options)));
		}
		/**
		Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
		*/
		start() {
			if (!this._isPaused) return this;
			this._isPaused = false;
			this._processQueue();
			return this;
		}
		/**
		Put queue execution on hold.
		*/
		pause() {
			this._isPaused = true;
		}
		/**
		Clear the queue.
		*/
		clear() {
			this._queue = new this._queueClass();
		}
		/**
		Can be called multiple times. Useful if you for example add additional items at a later time.
		
		@returns A promise that settles when the queue becomes empty.
		*/
		async onEmpty() {
			if (this._queue.size === 0) return;
			return new Promise((resolve) => {
				const existingResolve = this._resolveEmpty;
				this._resolveEmpty = () => {
					existingResolve();
					resolve();
				};
			});
		}
		/**
		The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
		
		@returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
		*/
		async onIdle() {
			if (this._pendingCount === 0 && this._queue.size === 0) return;
			return new Promise((resolve) => {
				const existingResolve = this._resolveIdle;
				this._resolveIdle = () => {
					existingResolve();
					resolve();
				};
			});
		}
		/**
		Size of the queue.
		*/
		get size() {
			return this._queue.size;
		}
		/**
		Size of the queue, filtered by the given options.
		
		For example, this can be used to find the number of items remaining in the queue with a specific priority level.
		*/
		sizeBy(options) {
			return this._queue.filter(options).length;
		}
		/**
		Number of pending promises.
		*/
		get pending() {
			return this._pendingCount;
		}
		/**
		Whether the queue is currently paused.
		*/
		get isPaused() {
			return this._isPaused;
		}
		get timeout() {
			return this._timeout;
		}
		/**
		Set the timeout for future operations.
		*/
		set timeout(milliseconds) {
			this._timeout = milliseconds;
		}
	};
	exports.default = PQueue;
} });

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/env.js
let globalEnv;
const isBrowser$1 = () => typeof window !== "undefined" && typeof window.document !== "undefined";
const isWebWorker$1 = () => typeof globalThis === "object" && globalThis.constructor && globalThis.constructor.name === "DedicatedWorkerGlobalScope";
const isJsDom$1 = () => typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
const isDeno$1 = () => typeof Deno !== "undefined";
const isNode$1 = () => typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined" && !isDeno$1();
const getEnv$1 = () => {
	if (globalEnv) return globalEnv;
	if (isBrowser$1()) globalEnv = "browser";
	else if (isNode$1()) globalEnv = "node";
	else if (isWebWorker$1()) globalEnv = "webworker";
	else if (isJsDom$1()) globalEnv = "jsdom";
	else if (isDeno$1()) globalEnv = "deno";
	else globalEnv = "other";
	return globalEnv;
};
let runtimeEnvironment$1;
function getRuntimeEnvironment$1() {
	if (runtimeEnvironment$1 === void 0) {
		const env = getEnv$1();
		const releaseEnv = getShas();
		runtimeEnvironment$1 = {
			library: "langsmith",
			runtime: env,
			sdk: "langsmith-js",
			sdk_version: __version__,
			...releaseEnv
		};
	}
	return runtimeEnvironment$1;
}
/**
* Retrieves the LangChain-specific metadata from the current runtime environment.
*
* @returns {Record<string, string>}
*  - A record of LangChain-specific metadata environment variables.
*/
function getLangChainEnvVarsMetadata() {
	const allEnvVars = getEnvironmentVariables() || {};
	const envVars = {};
	const excluded = [
		"LANGCHAIN_API_KEY",
		"LANGCHAIN_ENDPOINT",
		"LANGCHAIN_TRACING_V2",
		"LANGCHAIN_PROJECT",
		"LANGCHAIN_SESSION",
		"LANGSMITH_API_KEY",
		"LANGSMITH_ENDPOINT",
		"LANGSMITH_TRACING_V2",
		"LANGSMITH_PROJECT",
		"LANGSMITH_SESSION"
	];
	for (const [key, value] of Object.entries(allEnvVars)) if ((key.startsWith("LANGCHAIN_") || key.startsWith("LANGSMITH_")) && typeof value === "string" && !excluded.includes(key) && !key.toLowerCase().includes("key") && !key.toLowerCase().includes("secret") && !key.toLowerCase().includes("token")) if (key === "LANGCHAIN_REVISION_ID") envVars["revision_id"] = value;
	else envVars[key] = value;
	return envVars;
}
/**
* Retrieves the environment variables from the current runtime environment.
*
* This function is designed to operate in a variety of JS environments,
* including Node.js, Deno, browsers, etc.
*
* @returns {Record<string, string> | undefined}
*  - A record of environment variables if available.
*  - `undefined` if the environment does not support or allows access to environment variables.
*/
function getEnvironmentVariables() {
	try {
		if (typeof process !== "undefined" && process.env) return Object.entries(process.env).reduce((acc, [key, value]) => {
			acc[key] = String(value);
			return acc;
		}, {});
		return void 0;
	} catch (e) {
		return void 0;
	}
}
function getEnvironmentVariable$1(name) {
	try {
		return typeof process !== "undefined" ? process.env?.[name] : void 0;
	} catch (e) {
		return void 0;
	}
}
function getLangSmithEnvironmentVariable(name) {
	return getEnvironmentVariable$1(`LANGSMITH_${name}`) || getEnvironmentVariable$1(`LANGCHAIN_${name}`);
}
let cachedCommitSHAs;
/**
* Get the Git commit SHA from common environment variables
* used by different CI/CD platforms.
* @returns {string | undefined} The Git commit SHA or undefined if not found.
*/
function getShas() {
	if (cachedCommitSHAs !== void 0) return cachedCommitSHAs;
	const common_release_envs = [
		"VERCEL_GIT_COMMIT_SHA",
		"NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA",
		"COMMIT_REF",
		"RENDER_GIT_COMMIT",
		"CI_COMMIT_SHA",
		"CIRCLE_SHA1",
		"CF_PAGES_COMMIT_SHA",
		"REACT_APP_GIT_SHA",
		"SOURCE_VERSION",
		"GITHUB_SHA",
		"TRAVIS_COMMIT",
		"GIT_COMMIT",
		"BUILD_VCS_NUMBER",
		"bamboo_planRepository_revision",
		"Build.SourceVersion",
		"BITBUCKET_COMMIT",
		"DRONE_COMMIT_SHA",
		"SEMAPHORE_GIT_SHA",
		"BUILDKITE_COMMIT"
	];
	const shas = {};
	for (const env of common_release_envs) {
		const envVar = getEnvironmentVariable$1(env);
		if (envVar !== void 0) shas[env] = envVar;
	}
	cachedCommitSHAs = shas;
	return shas;
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/singletons/fetch.js
const DEFAULT_FETCH_IMPLEMENTATION = (...args) => fetch(...args);
const LANGSMITH_FETCH_IMPLEMENTATION_KEY = Symbol.for("ls:fetch_implementation");
const _globalFetchImplementationIsNodeFetch = () => {
	const fetchImpl = globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY];
	if (!fetchImpl) return false;
	return typeof fetchImpl === "function" && "Headers" in fetchImpl && "Request" in fetchImpl && "Response" in fetchImpl;
};
/**
* @internal
*/
const _getFetchImplementation = (debug$5) => {
	return async (...args) => {
		if (debug$5 || getLangSmithEnvironmentVariable("DEBUG") === "true") {
			const [url, options] = args;
			console.log(`→ ${options?.method || "GET"} ${url}`);
		}
		const res = await (globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY] ?? DEFAULT_FETCH_IMPLEMENTATION)(...args);
		if (debug$5 || getLangSmithEnvironmentVariable("DEBUG") === "true") console.log(`← ${res.status} ${res.statusText} ${res.url}`);
		return res;
	};
};

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/async_caller.js
var import_p_retry$2 = __toESM(require_p_retry(), 1);
var import_dist$2 = __toESM(require_dist(), 1);
const STATUS_NO_RETRY$1 = [
	400,
	401,
	403,
	404,
	405,
	406,
	407,
	408
];
const STATUS_IGNORE = [409];
/**
* A class that can be used to make async calls with concurrency and retry logic.
*
* This is useful for making calls to any kind of "expensive" external resource,
* be it because it's rate-limited, subject to network issues, etc.
*
* Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
* to `Infinity`. This means that by default, all calls will be made in parallel.
*
* Retries are limited by the `maxRetries` parameter, which defaults to 6. This
* means that by default, each call will be retried up to 6 times, with an
* exponential backoff between each attempt.
*/
var AsyncCaller$1 = class {
	constructor(params) {
		Object.defineProperty(this, "maxConcurrency", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "maxRetries", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "queue", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "onFailedResponseHook", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "debug", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.maxConcurrency = params.maxConcurrency ?? Infinity;
		this.maxRetries = params.maxRetries ?? 6;
		this.debug = params.debug;
		if ("default" in import_dist$2.default) this.queue = new import_dist$2.default.default({ concurrency: this.maxConcurrency });
		else this.queue = new import_dist$2.default({ concurrency: this.maxConcurrency });
		this.onFailedResponseHook = params?.onFailedResponseHook;
	}
	call(callable, ...args) {
		const onFailedResponseHook = this.onFailedResponseHook;
		return this.queue.add(() => (0, import_p_retry$2.default)(() => callable(...args).catch((error) => {
			if (error instanceof Error) throw error;
			else throw new Error(error);
		}), {
			async onFailedAttempt(error) {
				if (error.message.startsWith("Cancel") || error.message.startsWith("TimeoutError") || error.message.startsWith("AbortError")) throw error;
				if (error?.code === "ECONNABORTED") throw error;
				const response = error?.response;
				const status = response?.status;
				if (status) {
					if (STATUS_NO_RETRY$1.includes(+status)) throw error;
					else if (STATUS_IGNORE.includes(+status)) return;
					if (onFailedResponseHook) await onFailedResponseHook(response);
				}
			},
			retries: this.maxRetries,
			randomize: true
		}), { throwOnTimeout: true });
	}
	callWithOptions(options, callable, ...args) {
		if (options.signal) return Promise.race([this.call(callable, ...args), new Promise((_, reject) => {
			options.signal?.addEventListener("abort", () => {
				reject(new Error("AbortError"));
			});
		})]);
		return this.call(callable, ...args);
	}
	fetch(...args) {
		return this.call(() => _getFetchImplementation(this.debug)(...args).then((res) => res.ok ? res : Promise.reject(res)));
	}
};

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/messages.js
function isLangChainMessage(message) {
	return typeof message?._getType === "function";
}
function convertLangChainMessageToExample(message) {
	const converted = {
		type: message._getType(),
		data: { content: message.content }
	};
	if (message?.additional_kwargs && Object.keys(message.additional_kwargs).length > 0) converted.data.additional_kwargs = { ...message.additional_kwargs };
	return converted;
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/_uuid.js
function assertUuid(str, which) {
	if (!validate_default(str)) {
		const msg = which !== void 0 ? `Invalid UUID for ${which}: ${str}` : `Invalid UUID: ${str}`;
		throw new Error(msg);
	}
	return str;
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/warn.js
const warnedMessages = {};
function warnOnce(message) {
	if (!warnedMessages[message]) {
		console.warn(message);
		warnedMessages[message] = true;
	}
}

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js
var require_constants = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js"(exports, module) {
	const SEMVER_SPEC_VERSION = "2.0.0";
	const MAX_LENGTH$2 = 256;
	const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || 9007199254740991;
	const MAX_SAFE_COMPONENT_LENGTH$1 = 16;
	const MAX_SAFE_BUILD_LENGTH$1 = MAX_LENGTH$2 - 6;
	const RELEASE_TYPES = [
		"major",
		"premajor",
		"minor",
		"preminor",
		"patch",
		"prepatch",
		"prerelease"
	];
	module.exports = {
		MAX_LENGTH: MAX_LENGTH$2,
		MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH$1,
		MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH$1,
		MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
		RELEASE_TYPES,
		SEMVER_SPEC_VERSION,
		FLAG_INCLUDE_PRERELEASE: 1,
		FLAG_LOOSE: 2
	};
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js
var require_debug = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js"(exports, module) {
	const debug$4 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
	module.exports = debug$4;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js
var require_re = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js"(exports, module) {
	const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH: MAX_LENGTH$1 } = require_constants();
	const debug$3 = require_debug();
	exports = module.exports = {};
	const re$4 = exports.re = [];
	const safeRe = exports.safeRe = [];
	const src = exports.src = [];
	const safeSrc = exports.safeSrc = [];
	const t$4 = exports.t = {};
	let R = 0;
	const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
	const safeRegexReplacements = [
		["\\s", 1],
		["\\d", MAX_LENGTH$1],
		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
	];
	const makeSafeRegex = (value) => {
		for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
		return value;
	};
	const createToken = (name, value, isGlobal) => {
		const safe = makeSafeRegex(value);
		const index = R++;
		debug$3(name, index, value);
		t$4[name] = index;
		src[index] = value;
		safeSrc[index] = safe;
		re$4[index] = new RegExp(value, isGlobal ? "g" : void 0);
		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
	};
	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
	createToken("MAINVERSION", `(${src[t$4.NUMERICIDENTIFIER]})\\.(${src[t$4.NUMERICIDENTIFIER]})\\.(${src[t$4.NUMERICIDENTIFIER]})`);
	createToken("MAINVERSIONLOOSE", `(${src[t$4.NUMERICIDENTIFIERLOOSE]})\\.(${src[t$4.NUMERICIDENTIFIERLOOSE]})\\.(${src[t$4.NUMERICIDENTIFIERLOOSE]})`);
	createToken("PRERELEASEIDENTIFIER", `(?:${src[t$4.NONNUMERICIDENTIFIER]}|${src[t$4.NUMERICIDENTIFIER]})`);
	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t$4.NONNUMERICIDENTIFIER]}|${src[t$4.NUMERICIDENTIFIERLOOSE]})`);
	createToken("PRERELEASE", `(?:-(${src[t$4.PRERELEASEIDENTIFIER]}(?:\\.${src[t$4.PRERELEASEIDENTIFIER]})*))`);
	createToken("PRERELEASELOOSE", `(?:-?(${src[t$4.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t$4.PRERELEASEIDENTIFIERLOOSE]})*))`);
	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
	createToken("BUILD", `(?:\\+(${src[t$4.BUILDIDENTIFIER]}(?:\\.${src[t$4.BUILDIDENTIFIER]})*))`);
	createToken("FULLPLAIN", `v?${src[t$4.MAINVERSION]}${src[t$4.PRERELEASE]}?${src[t$4.BUILD]}?`);
	createToken("FULL", `^${src[t$4.FULLPLAIN]}$`);
	createToken("LOOSEPLAIN", `[v=\\s]*${src[t$4.MAINVERSIONLOOSE]}${src[t$4.PRERELEASELOOSE]}?${src[t$4.BUILD]}?`);
	createToken("LOOSE", `^${src[t$4.LOOSEPLAIN]}$`);
	createToken("GTLT", "((?:<|>)?=?)");
	createToken("XRANGEIDENTIFIERLOOSE", `${src[t$4.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
	createToken("XRANGEIDENTIFIER", `${src[t$4.NUMERICIDENTIFIER]}|x|X|\\*`);
	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t$4.XRANGEIDENTIFIER]})(?:\\.(${src[t$4.XRANGEIDENTIFIER]})(?:\\.(${src[t$4.XRANGEIDENTIFIER]})(?:${src[t$4.PRERELEASE]})?${src[t$4.BUILD]}?)?)?`);
	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t$4.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t$4.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t$4.XRANGEIDENTIFIERLOOSE]})(?:${src[t$4.PRERELEASELOOSE]})?${src[t$4.BUILD]}?)?)?`);
	createToken("XRANGE", `^${src[t$4.GTLT]}\\s*${src[t$4.XRANGEPLAIN]}$`);
	createToken("XRANGELOOSE", `^${src[t$4.GTLT]}\\s*${src[t$4.XRANGEPLAINLOOSE]}$`);
	createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
	createToken("COERCE", `${src[t$4.COERCEPLAIN]}(?:$|[^\\d])`);
	createToken("COERCEFULL", src[t$4.COERCEPLAIN] + `(?:${src[t$4.PRERELEASE]})?(?:${src[t$4.BUILD]})?(?:$|[^\\d])`);
	createToken("COERCERTL", src[t$4.COERCE], true);
	createToken("COERCERTLFULL", src[t$4.COERCEFULL], true);
	createToken("LONETILDE", "(?:~>?)");
	createToken("TILDETRIM", `(\\s*)${src[t$4.LONETILDE]}\\s+`, true);
	exports.tildeTrimReplace = "$1~";
	createToken("TILDE", `^${src[t$4.LONETILDE]}${src[t$4.XRANGEPLAIN]}$`);
	createToken("TILDELOOSE", `^${src[t$4.LONETILDE]}${src[t$4.XRANGEPLAINLOOSE]}$`);
	createToken("LONECARET", "(?:\\^)");
	createToken("CARETTRIM", `(\\s*)${src[t$4.LONECARET]}\\s+`, true);
	exports.caretTrimReplace = "$1^";
	createToken("CARET", `^${src[t$4.LONECARET]}${src[t$4.XRANGEPLAIN]}$`);
	createToken("CARETLOOSE", `^${src[t$4.LONECARET]}${src[t$4.XRANGEPLAINLOOSE]}$`);
	createToken("COMPARATORLOOSE", `^${src[t$4.GTLT]}\\s*(${src[t$4.LOOSEPLAIN]})$|^$`);
	createToken("COMPARATOR", `^${src[t$4.GTLT]}\\s*(${src[t$4.FULLPLAIN]})$|^$`);
	createToken("COMPARATORTRIM", `(\\s*)${src[t$4.GTLT]}\\s*(${src[t$4.LOOSEPLAIN]}|${src[t$4.XRANGEPLAIN]})`, true);
	exports.comparatorTrimReplace = "$1$2$3";
	createToken("HYPHENRANGE", `^\\s*(${src[t$4.XRANGEPLAIN]})\\s+-\\s+(${src[t$4.XRANGEPLAIN]})\\s*$`);
	createToken("HYPHENRANGELOOSE", `^\\s*(${src[t$4.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t$4.XRANGEPLAINLOOSE]})\\s*$`);
	createToken("STAR", "(<|>)?=?\\s*\\*");
	createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
	createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js"(exports, module) {
	const looseOption = Object.freeze({ loose: true });
	const emptyOpts = Object.freeze({});
	const parseOptions$3 = (options) => {
		if (!options) return emptyOpts;
		if (typeof options !== "object") return looseOption;
		return options;
	};
	module.exports = parseOptions$3;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js"(exports, module) {
	const numeric = /^[0-9]+$/;
	const compareIdentifiers$1 = (a, b) => {
		const anum = numeric.test(a);
		const bnum = numeric.test(b);
		if (anum && bnum) {
			a = +a;
			b = +b;
		}
		return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
	};
	const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
	module.exports = {
		compareIdentifiers: compareIdentifiers$1,
		rcompareIdentifiers
	};
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js
var require_semver$1 = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js"(exports, module) {
	const debug$2 = require_debug();
	const { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
	const { safeRe: re$3, t: t$3 } = require_re();
	const parseOptions$2 = require_parse_options();
	const { compareIdentifiers } = require_identifiers();
	var SemVer$15 = class SemVer$15 {
		constructor(version, options) {
			options = parseOptions$2(options);
			if (version instanceof SemVer$15) if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
			else version = version.version;
			else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
			if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
			debug$2("SemVer", version, options);
			this.options = options;
			this.loose = !!options.loose;
			this.includePrerelease = !!options.includePrerelease;
			const m = version.trim().match(options.loose ? re$3[t$3.LOOSE] : re$3[t$3.FULL]);
			if (!m) throw new TypeError(`Invalid Version: ${version}`);
			this.raw = version;
			this.major = +m[1];
			this.minor = +m[2];
			this.patch = +m[3];
			if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
			if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
			if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
			if (!m[4]) this.prerelease = [];
			else this.prerelease = m[4].split(".").map((id) => {
				if (/^[0-9]+$/.test(id)) {
					const num = +id;
					if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
				}
				return id;
			});
			this.build = m[5] ? m[5].split(".") : [];
			this.format();
		}
		format() {
			this.version = `${this.major}.${this.minor}.${this.patch}`;
			if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
			return this.version;
		}
		toString() {
			return this.version;
		}
		compare(other) {
			debug$2("SemVer.compare", this.version, this.options, other);
			if (!(other instanceof SemVer$15)) {
				if (typeof other === "string" && other === this.version) return 0;
				other = new SemVer$15(other, this.options);
			}
			if (other.version === this.version) return 0;
			return this.compareMain(other) || this.comparePre(other);
		}
		compareMain(other) {
			if (!(other instanceof SemVer$15)) other = new SemVer$15(other, this.options);
			return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
		}
		comparePre(other) {
			if (!(other instanceof SemVer$15)) other = new SemVer$15(other, this.options);
			if (this.prerelease.length && !other.prerelease.length) return -1;
			else if (!this.prerelease.length && other.prerelease.length) return 1;
			else if (!this.prerelease.length && !other.prerelease.length) return 0;
			let i = 0;
			do {
				const a = this.prerelease[i];
				const b = other.prerelease[i];
				debug$2("prerelease compare", i, a, b);
				if (a === void 0 && b === void 0) return 0;
				else if (b === void 0) return 1;
				else if (a === void 0) return -1;
				else if (a === b) continue;
				else return compareIdentifiers(a, b);
			} while (++i);
		}
		compareBuild(other) {
			if (!(other instanceof SemVer$15)) other = new SemVer$15(other, this.options);
			let i = 0;
			do {
				const a = this.build[i];
				const b = other.build[i];
				debug$2("build compare", i, a, b);
				if (a === void 0 && b === void 0) return 0;
				else if (b === void 0) return 1;
				else if (a === void 0) return -1;
				else if (a === b) continue;
				else return compareIdentifiers(a, b);
			} while (++i);
		}
		inc(release, identifier, identifierBase) {
			if (release.startsWith("pre")) {
				if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
				if (identifier) {
					const match = `-${identifier}`.match(this.options.loose ? re$3[t$3.PRERELEASELOOSE] : re$3[t$3.PRERELEASE]);
					if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
				}
			}
			switch (release) {
				case "premajor":
					this.prerelease.length = 0;
					this.patch = 0;
					this.minor = 0;
					this.major++;
					this.inc("pre", identifier, identifierBase);
					break;
				case "preminor":
					this.prerelease.length = 0;
					this.patch = 0;
					this.minor++;
					this.inc("pre", identifier, identifierBase);
					break;
				case "prepatch":
					this.prerelease.length = 0;
					this.inc("patch", identifier, identifierBase);
					this.inc("pre", identifier, identifierBase);
					break;
				case "prerelease":
					if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
					this.inc("pre", identifier, identifierBase);
					break;
				case "release":
					if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
					this.prerelease.length = 0;
					break;
				case "major":
					if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
					this.minor = 0;
					this.patch = 0;
					this.prerelease = [];
					break;
				case "minor":
					if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
					this.patch = 0;
					this.prerelease = [];
					break;
				case "patch":
					if (this.prerelease.length === 0) this.patch++;
					this.prerelease = [];
					break;
				case "pre": {
					const base = Number(identifierBase) ? 1 : 0;
					if (this.prerelease.length === 0) this.prerelease = [base];
					else {
						let i = this.prerelease.length;
						while (--i >= 0) if (typeof this.prerelease[i] === "number") {
							this.prerelease[i]++;
							i = -2;
						}
						if (i === -1) {
							if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
							this.prerelease.push(base);
						}
					}
					if (identifier) {
						let prerelease$2 = [identifier, base];
						if (identifierBase === false) prerelease$2 = [identifier];
						if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
							if (isNaN(this.prerelease[1])) this.prerelease = prerelease$2;
						} else this.prerelease = prerelease$2;
					}
					break;
				}
				default: throw new Error(`invalid increment argument: ${release}`);
			}
			this.raw = this.format();
			if (this.build.length) this.raw += `+${this.build.join(".")}`;
			return this;
		}
	};
	module.exports = SemVer$15;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/parse.js
var require_parse = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/parse.js"(exports, module) {
	const SemVer$14 = require_semver$1();
	const parse$6 = (version, options, throwErrors = false) => {
		if (version instanceof SemVer$14) return version;
		try {
			return new SemVer$14(version, options);
		} catch (er) {
			if (!throwErrors) return null;
			throw er;
		}
	};
	module.exports = parse$6;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/valid.js
var require_valid$1 = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/valid.js"(exports, module) {
	const parse$5 = require_parse();
	const valid$1 = (version, options) => {
		const v = parse$5(version, options);
		return v ? v.version : null;
	};
	module.exports = valid$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/clean.js
var require_clean = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/clean.js"(exports, module) {
	const parse$4 = require_parse();
	const clean$1 = (version, options) => {
		const s = parse$4(version.trim().replace(/^[=v]+/, ""), options);
		return s ? s.version : null;
	};
	module.exports = clean$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js
var require_inc = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js"(exports, module) {
	const SemVer$13 = require_semver$1();
	const inc$1 = (version, release, options, identifier, identifierBase) => {
		if (typeof options === "string") {
			identifierBase = identifier;
			identifier = options;
			options = void 0;
		}
		try {
			return new SemVer$13(version instanceof SemVer$13 ? version.version : version, options).inc(release, identifier, identifierBase).version;
		} catch (er) {
			return null;
		}
	};
	module.exports = inc$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js
var require_diff = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js"(exports, module) {
	const parse$3 = require_parse();
	const diff$1 = (version1, version2) => {
		const v1 = parse$3(version1, null, true);
		const v2 = parse$3(version2, null, true);
		const comparison = v1.compare(v2);
		if (comparison === 0) return null;
		const v1Higher = comparison > 0;
		const highVersion = v1Higher ? v1 : v2;
		const lowVersion = v1Higher ? v2 : v1;
		const highHasPre = !!highVersion.prerelease.length;
		const lowHasPre = !!lowVersion.prerelease.length;
		if (lowHasPre && !highHasPre) {
			if (!lowVersion.patch && !lowVersion.minor) return "major";
			if (lowVersion.compareMain(highVersion) === 0) {
				if (lowVersion.minor && !lowVersion.patch) return "minor";
				return "patch";
			}
		}
		const prefix$1 = highHasPre ? "pre" : "";
		if (v1.major !== v2.major) return prefix$1 + "major";
		if (v1.minor !== v2.minor) return prefix$1 + "minor";
		if (v1.patch !== v2.patch) return prefix$1 + "patch";
		return "prerelease";
	};
	module.exports = diff$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js
var require_major = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js"(exports, module) {
	const SemVer$12 = require_semver$1();
	const major$1 = (a, loose) => new SemVer$12(a, loose).major;
	module.exports = major$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js
var require_minor = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js"(exports, module) {
	const SemVer$11 = require_semver$1();
	const minor$1 = (a, loose) => new SemVer$11(a, loose).minor;
	module.exports = minor$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js
var require_patch = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js"(exports, module) {
	const SemVer$10 = require_semver$1();
	const patch$1 = (a, loose) => new SemVer$10(a, loose).patch;
	module.exports = patch$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js"(exports, module) {
	const parse$2 = require_parse();
	const prerelease$1 = (version, options) => {
		const parsed = parse$2(version, options);
		return parsed && parsed.prerelease.length ? parsed.prerelease : null;
	};
	module.exports = prerelease$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js
var require_compare = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js"(exports, module) {
	const SemVer$9 = require_semver$1();
	const compare$12 = (a, b, loose) => new SemVer$9(a, loose).compare(new SemVer$9(b, loose));
	module.exports = compare$12;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js"(exports, module) {
	const compare$11 = require_compare();
	const rcompare$1 = (a, b, loose) => compare$11(b, a, loose);
	module.exports = rcompare$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js"(exports, module) {
	const compare$10 = require_compare();
	const compareLoose$1 = (a, b) => compare$10(a, b, true);
	module.exports = compareLoose$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js"(exports, module) {
	const SemVer$8 = require_semver$1();
	const compareBuild$3 = (a, b, loose) => {
		const versionA = new SemVer$8(a, loose);
		const versionB = new SemVer$8(b, loose);
		return versionA.compare(versionB) || versionA.compareBuild(versionB);
	};
	module.exports = compareBuild$3;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js
var require_sort = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js"(exports, module) {
	const compareBuild$2 = require_compare_build();
	const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose));
	module.exports = sort$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js"(exports, module) {
	const compareBuild$1 = require_compare_build();
	const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose));
	module.exports = rsort$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js
var require_gt = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js"(exports, module) {
	const compare$9 = require_compare();
	const gt$4 = (a, b, loose) => compare$9(a, b, loose) > 0;
	module.exports = gt$4;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js
var require_lt = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js"(exports, module) {
	const compare$8 = require_compare();
	const lt$3 = (a, b, loose) => compare$8(a, b, loose) < 0;
	module.exports = lt$3;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js
var require_eq = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js"(exports, module) {
	const compare$7 = require_compare();
	const eq$2 = (a, b, loose) => compare$7(a, b, loose) === 0;
	module.exports = eq$2;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js
var require_neq = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js"(exports, module) {
	const compare$6 = require_compare();
	const neq$2 = (a, b, loose) => compare$6(a, b, loose) !== 0;
	module.exports = neq$2;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js
var require_gte = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js"(exports, module) {
	const compare$5 = require_compare();
	const gte$3 = (a, b, loose) => compare$5(a, b, loose) >= 0;
	module.exports = gte$3;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js
var require_lte = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js"(exports, module) {
	const compare$4 = require_compare();
	const lte$3 = (a, b, loose) => compare$4(a, b, loose) <= 0;
	module.exports = lte$3;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js"(exports, module) {
	const eq$1 = require_eq();
	const neq$1 = require_neq();
	const gt$3 = require_gt();
	const gte$2 = require_gte();
	const lt$2 = require_lt();
	const lte$2 = require_lte();
	const cmp$2 = (a, op, b, loose) => {
		switch (op) {
			case "===":
				if (typeof a === "object") a = a.version;
				if (typeof b === "object") b = b.version;
				return a === b;
			case "!==":
				if (typeof a === "object") a = a.version;
				if (typeof b === "object") b = b.version;
				return a !== b;
			case "":
			case "=":
			case "==": return eq$1(a, b, loose);
			case "!=": return neq$1(a, b, loose);
			case ">": return gt$3(a, b, loose);
			case ">=": return gte$2(a, b, loose);
			case "<": return lt$2(a, b, loose);
			case "<=": return lte$2(a, b, loose);
			default: throw new TypeError(`Invalid operator: ${op}`);
		}
	};
	module.exports = cmp$2;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js"(exports, module) {
	const SemVer$7 = require_semver$1();
	const parse$1 = require_parse();
	const { safeRe: re$2, t: t$2 } = require_re();
	const coerce$1 = (version, options) => {
		if (version instanceof SemVer$7) return version;
		if (typeof version === "number") version = String(version);
		if (typeof version !== "string") return null;
		options = options || {};
		let match = null;
		if (!options.rtl) match = version.match(options.includePrerelease ? re$2[t$2.COERCEFULL] : re$2[t$2.COERCE]);
		else {
			const coerceRtlRegex = options.includePrerelease ? re$2[t$2.COERCERTLFULL] : re$2[t$2.COERCERTL];
			let next;
			while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
				if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
				coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
			}
			coerceRtlRegex.lastIndex = -1;
		}
		if (match === null) return null;
		const major$2 = match[2];
		const minor$2 = match[3] || "0";
		const patch$2 = match[4] || "0";
		const prerelease$2 = options.includePrerelease && match[5] ? `-${match[5]}` : "";
		const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
		return parse$1(`${major$2}.${minor$2}.${patch$2}${prerelease$2}${build}`, options);
	};
	module.exports = coerce$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js"(exports, module) {
	var LRUCache = class {
		constructor() {
			this.max = 1e3;
			this.map = /* @__PURE__ */ new Map();
		}
		get(key) {
			const value = this.map.get(key);
			if (value === void 0) return void 0;
			else {
				this.map.delete(key);
				this.map.set(key, value);
				return value;
			}
		}
		delete(key) {
			return this.map.delete(key);
		}
		set(key, value) {
			const deleted = this.delete(key);
			if (!deleted && value !== void 0) {
				if (this.map.size >= this.max) {
					const firstKey = this.map.keys().next().value;
					this.delete(firstKey);
				}
				this.map.set(key, value);
			}
			return this;
		}
	};
	module.exports = LRUCache;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js
var require_range = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js"(exports, module) {
	const SPACE_CHARACTERS = /\s+/g;
	var Range$11 = class Range$11 {
		constructor(range, options) {
			options = parseOptions$1(options);
			if (range instanceof Range$11) if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
			else return new Range$11(range.raw, options);
			if (range instanceof Comparator$4) {
				this.raw = range.value;
				this.set = [[range]];
				this.formatted = void 0;
				return this;
			}
			this.options = options;
			this.loose = !!options.loose;
			this.includePrerelease = !!options.includePrerelease;
			this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
			this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
			if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
			if (this.set.length > 1) {
				const first = this.set[0];
				this.set = this.set.filter((c) => !isNullSet(c[0]));
				if (this.set.length === 0) this.set = [first];
				else if (this.set.length > 1) {
					for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
						this.set = [c];
						break;
					}
				}
			}
			this.formatted = void 0;
		}
		get range() {
			if (this.formatted === void 0) {
				this.formatted = "";
				for (let i = 0; i < this.set.length; i++) {
					if (i > 0) this.formatted += "||";
					const comps = this.set[i];
					for (let k = 0; k < comps.length; k++) {
						if (k > 0) this.formatted += " ";
						this.formatted += comps[k].toString().trim();
					}
				}
			}
			return this.formatted;
		}
		format() {
			return this.range;
		}
		toString() {
			return this.range;
		}
		parseRange(range) {
			const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
			const memoKey = memoOpts + ":" + range;
			const cached = cache.get(memoKey);
			if (cached) return cached;
			const loose = this.options.loose;
			const hr = loose ? re$1[t$1.HYPHENRANGELOOSE] : re$1[t$1.HYPHENRANGE];
			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
			debug$1("hyphen replace", range);
			range = range.replace(re$1[t$1.COMPARATORTRIM], comparatorTrimReplace);
			debug$1("comparator trim", range);
			range = range.replace(re$1[t$1.TILDETRIM], tildeTrimReplace);
			debug$1("tilde trim", range);
			range = range.replace(re$1[t$1.CARETTRIM], caretTrimReplace);
			debug$1("caret trim", range);
			let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
			if (loose) rangeList = rangeList.filter((comp) => {
				debug$1("loose invalid filter", comp, this.options);
				return !!comp.match(re$1[t$1.COMPARATORLOOSE]);
			});
			debug$1("range list", rangeList);
			const rangeMap = /* @__PURE__ */ new Map();
			const comparators = rangeList.map((comp) => new Comparator$4(comp, this.options));
			for (const comp of comparators) {
				if (isNullSet(comp)) return [comp];
				rangeMap.set(comp.value, comp);
			}
			if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
			const result = [...rangeMap.values()];
			cache.set(memoKey, result);
			return result;
		}
		intersects(range, options) {
			if (!(range instanceof Range$11)) throw new TypeError("a Range is required");
			return this.set.some((thisComparators) => {
				return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
					return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
						return rangeComparators.every((rangeComparator) => {
							return thisComparator.intersects(rangeComparator, options);
						});
					});
				});
			});
		}
		test(version) {
			if (!version) return false;
			if (typeof version === "string") try {
				version = new SemVer$6(version, this.options);
			} catch (er) {
				return false;
			}
			for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
			return false;
		}
	};
	module.exports = Range$11;
	const LRU = require_lrucache();
	const cache = new LRU();
	const parseOptions$1 = require_parse_options();
	const Comparator$4 = require_comparator();
	const debug$1 = require_debug();
	const SemVer$6 = require_semver$1();
	const { safeRe: re$1, t: t$1, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
	const isNullSet = (c) => c.value === "<0.0.0-0";
	const isAny = (c) => c.value === "";
	const isSatisfiable = (comparators, options) => {
		let result = true;
		const remainingComparators = comparators.slice();
		let testComparator = remainingComparators.pop();
		while (result && remainingComparators.length) {
			result = remainingComparators.every((otherComparator) => {
				return testComparator.intersects(otherComparator, options);
			});
			testComparator = remainingComparators.pop();
		}
		return result;
	};
	const parseComparator = (comp, options) => {
		debug$1("comp", comp, options);
		comp = replaceCarets(comp, options);
		debug$1("caret", comp);
		comp = replaceTildes(comp, options);
		debug$1("tildes", comp);
		comp = replaceXRanges(comp, options);
		debug$1("xrange", comp);
		comp = replaceStars(comp, options);
		debug$1("stars", comp);
		return comp;
	};
	const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
	const replaceTildes = (comp, options) => {
		return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
	};
	const replaceTilde = (comp, options) => {
		const r = options.loose ? re$1[t$1.TILDELOOSE] : re$1[t$1.TILDE];
		return comp.replace(r, (_, M, m, p, pr) => {
			debug$1("tilde", comp, _, M, m, p, pr);
			let ret;
			if (isX(M)) ret = "";
			else if (isX(m)) ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
			else if (isX(p)) ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
			else if (pr) {
				debug$1("replaceTilde pr", pr);
				ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
			} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
			debug$1("tilde return", ret);
			return ret;
		});
	};
	const replaceCarets = (comp, options) => {
		return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
	};
	const replaceCaret = (comp, options) => {
		debug$1("caret", comp, options);
		const r = options.loose ? re$1[t$1.CARETLOOSE] : re$1[t$1.CARET];
		const z = options.includePrerelease ? "-0" : "";
		return comp.replace(r, (_, M, m, p, pr) => {
			debug$1("caret", comp, _, M, m, p, pr);
			let ret;
			if (isX(M)) ret = "";
			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
			else if (isX(p)) if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
			else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
			else if (pr) {
				debug$1("replaceCaret pr", pr);
				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
				else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
				else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
			} else {
				debug$1("no pr");
				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
				else ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
				else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
			}
			debug$1("caret return", ret);
			return ret;
		});
	};
	const replaceXRanges = (comp, options) => {
		debug$1("replaceXRanges", comp, options);
		return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
	};
	const replaceXRange = (comp, options) => {
		comp = comp.trim();
		const r = options.loose ? re$1[t$1.XRANGELOOSE] : re$1[t$1.XRANGE];
		return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
			debug$1("xRange", comp, ret, gtlt, M, m, p, pr);
			const xM = isX(M);
			const xm = xM || isX(m);
			const xp = xm || isX(p);
			const anyX = xp;
			if (gtlt === "=" && anyX) gtlt = "";
			pr = options.includePrerelease ? "-0" : "";
			if (xM) if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
			else ret = "*";
			else if (gtlt && anyX) {
				if (xm) m = 0;
				p = 0;
				if (gtlt === ">") {
					gtlt = ">=";
					if (xm) {
						M = +M + 1;
						m = 0;
						p = 0;
					} else {
						m = +m + 1;
						p = 0;
					}
				} else if (gtlt === "<=") {
					gtlt = "<";
					if (xm) M = +M + 1;
					else m = +m + 1;
				}
				if (gtlt === "<") pr = "-0";
				ret = `${gtlt + M}.${m}.${p}${pr}`;
			} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
			else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
			debug$1("xRange return", ret);
			return ret;
		});
	};
	const replaceStars = (comp, options) => {
		debug$1("replaceStars", comp, options);
		return comp.trim().replace(re$1[t$1.STAR], "");
	};
	const replaceGTE0 = (comp, options) => {
		debug$1("replaceGTE0", comp, options);
		return comp.trim().replace(re$1[options.includePrerelease ? t$1.GTE0PRE : t$1.GTE0], "");
	};
	const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
		if (isX(fM)) from = "";
		else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
		else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
		else if (fpr) from = `>=${from}`;
		else from = `>=${from}${incPr ? "-0" : ""}`;
		if (isX(tM)) to = "";
		else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
		else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
		else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
		else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
		else to = `<=${to}`;
		return `${from} ${to}`.trim();
	};
	const testSet = (set, version, options) => {
		for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
		if (version.prerelease.length && !options.includePrerelease) {
			for (let i = 0; i < set.length; i++) {
				debug$1(set[i].semver);
				if (set[i].semver === Comparator$4.ANY) continue;
				if (set[i].semver.prerelease.length > 0) {
					const allowed = set[i].semver;
					if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
				}
			}
			return false;
		}
		return true;
	};
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js"(exports, module) {
	const ANY$2 = Symbol("SemVer ANY");
	var Comparator$3 = class Comparator$3 {
		static get ANY() {
			return ANY$2;
		}
		constructor(comp, options) {
			options = parseOptions(options);
			if (comp instanceof Comparator$3) if (comp.loose === !!options.loose) return comp;
			else comp = comp.value;
			comp = comp.trim().split(/\s+/).join(" ");
			debug("comparator", comp, options);
			this.options = options;
			this.loose = !!options.loose;
			this.parse(comp);
			if (this.semver === ANY$2) this.value = "";
			else this.value = this.operator + this.semver.version;
			debug("comp", this);
		}
		parse(comp) {
			const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
			const m = comp.match(r);
			if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
			this.operator = m[1] !== void 0 ? m[1] : "";
			if (this.operator === "=") this.operator = "";
			if (!m[2]) this.semver = ANY$2;
			else this.semver = new SemVer$5(m[2], this.options.loose);
		}
		toString() {
			return this.value;
		}
		test(version) {
			debug("Comparator.test", version, this.options.loose);
			if (this.semver === ANY$2 || version === ANY$2) return true;
			if (typeof version === "string") try {
				version = new SemVer$5(version, this.options);
			} catch (er) {
				return false;
			}
			return cmp$1(version, this.operator, this.semver, this.options);
		}
		intersects(comp, options) {
			if (!(comp instanceof Comparator$3)) throw new TypeError("a Comparator is required");
			if (this.operator === "") {
				if (this.value === "") return true;
				return new Range$10(comp.value, options).test(this.value);
			} else if (comp.operator === "") {
				if (comp.value === "") return true;
				return new Range$10(this.value, options).test(comp.semver);
			}
			options = parseOptions(options);
			if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
			if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
			if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
			if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
			if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
			if (cmp$1(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
			if (cmp$1(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
			return false;
		}
	};
	module.exports = Comparator$3;
	const parseOptions = require_parse_options();
	const { safeRe: re, t } = require_re();
	const cmp$1 = require_cmp();
	const debug = require_debug();
	const SemVer$5 = require_semver$1();
	const Range$10 = require_range();
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js"(exports, module) {
	const Range$9 = require_range();
	const satisfies$4 = (version, range, options) => {
		try {
			range = new Range$9(range, options);
		} catch (er) {
			return false;
		}
		return range.test(version);
	};
	module.exports = satisfies$4;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js"(exports, module) {
	const Range$8 = require_range();
	const toComparators$1 = (range, options) => new Range$8(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
	module.exports = toComparators$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
	const SemVer$4 = require_semver$1();
	const Range$7 = require_range();
	const maxSatisfying$1 = (versions, range, options) => {
		let max = null;
		let maxSV = null;
		let rangeObj = null;
		try {
			rangeObj = new Range$7(range, options);
		} catch (er) {
			return null;
		}
		versions.forEach((v) => {
			if (rangeObj.test(v)) {
				if (!max || maxSV.compare(v) === -1) {
					max = v;
					maxSV = new SemVer$4(max, options);
				}
			}
		});
		return max;
	};
	module.exports = maxSatisfying$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
	const SemVer$3 = require_semver$1();
	const Range$6 = require_range();
	const minSatisfying$1 = (versions, range, options) => {
		let min = null;
		let minSV = null;
		let rangeObj = null;
		try {
			rangeObj = new Range$6(range, options);
		} catch (er) {
			return null;
		}
		versions.forEach((v) => {
			if (rangeObj.test(v)) {
				if (!min || minSV.compare(v) === 1) {
					min = v;
					minSV = new SemVer$3(min, options);
				}
			}
		});
		return min;
	};
	module.exports = minSatisfying$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js"(exports, module) {
	const SemVer$2 = require_semver$1();
	const Range$5 = require_range();
	const gt$2 = require_gt();
	const minVersion$1 = (range, loose) => {
		range = new Range$5(range, loose);
		let minver = new SemVer$2("0.0.0");
		if (range.test(minver)) return minver;
		minver = new SemVer$2("0.0.0-0");
		if (range.test(minver)) return minver;
		minver = null;
		for (let i = 0; i < range.set.length; ++i) {
			const comparators = range.set[i];
			let setMin = null;
			comparators.forEach((comparator) => {
				const compver = new SemVer$2(comparator.semver.version);
				switch (comparator.operator) {
					case ">":
						if (compver.prerelease.length === 0) compver.patch++;
						else compver.prerelease.push(0);
						compver.raw = compver.format();
					case "":
					case ">=":
						if (!setMin || gt$2(compver, setMin)) setMin = compver;
						break;
					case "<":
					case "<=": break;
					default: throw new Error(`Unexpected operation: ${comparator.operator}`);
				}
			});
			if (setMin && (!minver || gt$2(minver, setMin))) minver = setMin;
		}
		if (minver && range.test(minver)) return minver;
		return null;
	};
	module.exports = minVersion$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js
var require_valid = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js"(exports, module) {
	const Range$4 = require_range();
	const validRange$1 = (range, options) => {
		try {
			return new Range$4(range, options).range || "*";
		} catch (er) {
			return null;
		}
	};
	module.exports = validRange$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js
var require_outside = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js"(exports, module) {
	const SemVer$1 = require_semver$1();
	const Comparator$2 = require_comparator();
	const { ANY: ANY$1 } = Comparator$2;
	const Range$3 = require_range();
	const satisfies$3 = require_satisfies();
	const gt$1 = require_gt();
	const lt$1 = require_lt();
	const lte$1 = require_lte();
	const gte$1 = require_gte();
	const outside$3 = (version, range, hilo, options) => {
		version = new SemVer$1(version, options);
		range = new Range$3(range, options);
		let gtfn, ltefn, ltfn, comp, ecomp;
		switch (hilo) {
			case ">":
				gtfn = gt$1;
				ltefn = lte$1;
				ltfn = lt$1;
				comp = ">";
				ecomp = ">=";
				break;
			case "<":
				gtfn = lt$1;
				ltefn = gte$1;
				ltfn = gt$1;
				comp = "<";
				ecomp = "<=";
				break;
			default: throw new TypeError("Must provide a hilo val of \"<\" or \">\"");
		}
		if (satisfies$3(version, range, options)) return false;
		for (let i = 0; i < range.set.length; ++i) {
			const comparators = range.set[i];
			let high = null;
			let low = null;
			comparators.forEach((comparator) => {
				if (comparator.semver === ANY$1) comparator = new Comparator$2(">=0.0.0");
				high = high || comparator;
				low = low || comparator;
				if (gtfn(comparator.semver, high.semver, options)) high = comparator;
				else if (ltfn(comparator.semver, low.semver, options)) low = comparator;
			});
			if (high.operator === comp || high.operator === ecomp) return false;
			if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;
			else if (low.operator === ecomp && ltfn(version, low.semver)) return false;
		}
		return true;
	};
	module.exports = outside$3;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js"(exports, module) {
	const outside$2 = require_outside();
	const gtr$1 = (version, range, options) => outside$2(version, range, ">", options);
	module.exports = gtr$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js"(exports, module) {
	const outside$1 = require_outside();
	const ltr$1 = (version, range, options) => outside$1(version, range, "<", options);
	module.exports = ltr$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js"(exports, module) {
	const Range$2 = require_range();
	const intersects$1 = (r1, r2, options) => {
		r1 = new Range$2(r1, options);
		r2 = new Range$2(r2, options);
		return r1.intersects(r2, options);
	};
	module.exports = intersects$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js"(exports, module) {
	const satisfies$2 = require_satisfies();
	const compare$3 = require_compare();
	module.exports = (versions, range, options) => {
		const set = [];
		let first = null;
		let prev = null;
		const v = versions.sort((a, b) => compare$3(a, b, options));
		for (const version of v) {
			const included = satisfies$2(version, range, options);
			if (included) {
				prev = version;
				if (!first) first = version;
			} else {
				if (prev) set.push([first, prev]);
				prev = null;
				first = null;
			}
		}
		if (first) set.push([first, null]);
		const ranges = [];
		for (const [min, max] of set) if (min === max) ranges.push(min);
		else if (!max && min === v[0]) ranges.push("*");
		else if (!max) ranges.push(`>=${min}`);
		else if (min === v[0]) ranges.push(`<=${max}`);
		else ranges.push(`${min} - ${max}`);
		const simplified = ranges.join(" || ");
		const original = typeof range.raw === "string" ? range.raw : String(range);
		return simplified.length < original.length ? simplified : range;
	};
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js
var require_subset = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js"(exports, module) {
	const Range$1 = require_range();
	const Comparator$1 = require_comparator();
	const { ANY } = Comparator$1;
	const satisfies$1 = require_satisfies();
	const compare$2 = require_compare();
	const subset$1 = (sub, dom, options = {}) => {
		if (sub === dom) return true;
		sub = new Range$1(sub, options);
		dom = new Range$1(dom, options);
		let sawNonNull = false;
		OUTER: for (const simpleSub of sub.set) {
			for (const simpleDom of dom.set) {
				const isSub = simpleSubset(simpleSub, simpleDom, options);
				sawNonNull = sawNonNull || isSub !== null;
				if (isSub) continue OUTER;
			}
			if (sawNonNull) return false;
		}
		return true;
	};
	const minimumVersionWithPreRelease = [new Comparator$1(">=0.0.0-0")];
	const minimumVersion = [new Comparator$1(">=0.0.0")];
	const simpleSubset = (sub, dom, options) => {
		if (sub === dom) return true;
		if (sub.length === 1 && sub[0].semver === ANY) if (dom.length === 1 && dom[0].semver === ANY) return true;
		else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
		else sub = minimumVersion;
		if (dom.length === 1 && dom[0].semver === ANY) if (options.includePrerelease) return true;
		else dom = minimumVersion;
		const eqSet = /* @__PURE__ */ new Set();
		let gt$5, lt$4;
		for (const c of sub) if (c.operator === ">" || c.operator === ">=") gt$5 = higherGT(gt$5, c, options);
		else if (c.operator === "<" || c.operator === "<=") lt$4 = lowerLT(lt$4, c, options);
		else eqSet.add(c.semver);
		if (eqSet.size > 1) return null;
		let gtltComp;
		if (gt$5 && lt$4) {
			gtltComp = compare$2(gt$5.semver, lt$4.semver, options);
			if (gtltComp > 0) return null;
			else if (gtltComp === 0 && (gt$5.operator !== ">=" || lt$4.operator !== "<=")) return null;
		}
		for (const eq$3 of eqSet) {
			if (gt$5 && !satisfies$1(eq$3, String(gt$5), options)) return null;
			if (lt$4 && !satisfies$1(eq$3, String(lt$4), options)) return null;
			for (const c of dom) if (!satisfies$1(eq$3, String(c), options)) return false;
			return true;
		}
		let higher, lower;
		let hasDomLT, hasDomGT;
		let needDomLTPre = lt$4 && !options.includePrerelease && lt$4.semver.prerelease.length ? lt$4.semver : false;
		let needDomGTPre = gt$5 && !options.includePrerelease && gt$5.semver.prerelease.length ? gt$5.semver : false;
		if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt$4.operator === "<" && needDomLTPre.prerelease[0] === 0) needDomLTPre = false;
		for (const c of dom) {
			hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
			hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
			if (gt$5) {
				if (needDomGTPre) {
					if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;
				}
				if (c.operator === ">" || c.operator === ">=") {
					higher = higherGT(gt$5, c, options);
					if (higher === c && higher !== gt$5) return false;
				} else if (gt$5.operator === ">=" && !satisfies$1(gt$5.semver, String(c), options)) return false;
			}
			if (lt$4) {
				if (needDomLTPre) {
					if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;
				}
				if (c.operator === "<" || c.operator === "<=") {
					lower = lowerLT(lt$4, c, options);
					if (lower === c && lower !== lt$4) return false;
				} else if (lt$4.operator === "<=" && !satisfies$1(lt$4.semver, String(c), options)) return false;
			}
			if (!c.operator && (lt$4 || gt$5) && gtltComp !== 0) return false;
		}
		if (gt$5 && hasDomLT && !lt$4 && gtltComp !== 0) return false;
		if (lt$4 && hasDomGT && !gt$5 && gtltComp !== 0) return false;
		if (needDomGTPre || needDomLTPre) return false;
		return true;
	};
	const higherGT = (a, b, options) => {
		if (!a) return b;
		const comp = compare$2(a.semver, b.semver, options);
		return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
	};
	const lowerLT = (a, b, options) => {
		if (!a) return b;
		const comp = compare$2(a.semver, b.semver, options);
		return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
	};
	module.exports = subset$1;
} });

//#endregion
//#region node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js
var require_semver = __commonJS({ "node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js"(exports, module) {
	const internalRe = require_re();
	const constants = require_constants();
	const SemVer = require_semver$1();
	const identifiers = require_identifiers();
	const parse = require_parse();
	const valid = require_valid$1();
	const clean = require_clean();
	const inc = require_inc();
	const diff = require_diff();
	const major = require_major();
	const minor = require_minor();
	const patch = require_patch();
	const prerelease = require_prerelease();
	const compare$1 = require_compare();
	const rcompare = require_rcompare();
	const compareLoose = require_compare_loose();
	const compareBuild = require_compare_build();
	const sort = require_sort();
	const rsort = require_rsort();
	const gt = require_gt();
	const lt = require_lt();
	const eq = require_eq();
	const neq = require_neq();
	const gte = require_gte();
	const lte = require_lte();
	const cmp = require_cmp();
	const coerce = require_coerce();
	const Comparator = require_comparator();
	const Range = require_range();
	const satisfies = require_satisfies();
	const toComparators = require_to_comparators();
	const maxSatisfying = require_max_satisfying();
	const minSatisfying = require_min_satisfying();
	const minVersion = require_min_version();
	const validRange = require_valid();
	const outside = require_outside();
	const gtr = require_gtr();
	const ltr = require_ltr();
	const intersects = require_intersects();
	const simplifyRange = require_simplify();
	const subset = require_subset();
	module.exports = {
		parse,
		valid,
		clean,
		inc,
		diff,
		major,
		minor,
		patch,
		prerelease,
		compare: compare$1,
		rcompare,
		compareLoose,
		compareBuild,
		sort,
		rsort,
		gt,
		lt,
		eq,
		neq,
		gte,
		lte,
		cmp,
		coerce,
		Comparator,
		Range,
		satisfies,
		toComparators,
		maxSatisfying,
		minSatisfying,
		minVersion,
		validRange,
		outside,
		gtr,
		ltr,
		intersects,
		simplifyRange,
		subset,
		SemVer,
		re: internalRe.re,
		src: internalRe.src,
		tokens: internalRe.t,
		SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
		RELEASE_TYPES: constants.RELEASE_TYPES,
		compareIdentifiers: identifiers.compareIdentifiers,
		rcompareIdentifiers: identifiers.rcompareIdentifiers
	};
} });

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/prompts.js
var import_semver = __toESM(require_semver(), 1);
function parsePromptIdentifier(identifier) {
	if (!identifier || identifier.split("/").length > 2 || identifier.startsWith("/") || identifier.endsWith("/") || identifier.split(":").length > 2) throw new Error(`Invalid identifier format: ${identifier}`);
	const [ownerNamePart, commitPart] = identifier.split(":");
	const commit = commitPart || "latest";
	if (ownerNamePart.includes("/")) {
		const [owner, name] = ownerNamePart.split("/", 2);
		if (!owner || !name) throw new Error(`Invalid identifier format: ${identifier}`);
		return [
			owner,
			name,
			commit
		];
	} else {
		if (!ownerNamePart) throw new Error(`Invalid identifier format: ${identifier}`);
		return [
			"-",
			ownerNamePart,
			commit
		];
	}
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/error.js
/**
* LangSmithConflictError
*
* Represents an error that occurs when there's a conflict during an operation,
* typically corresponding to HTTP 409 status code responses.
*
* This error is thrown when an attempt to create or modify a resource conflicts
* with the current state of the resource on the server. Common scenarios include:
* - Attempting to create a resource that already exists
* - Trying to update a resource that has been modified by another process
* - Violating a uniqueness constraint in the data
*
* @extends Error
*
* @example
* try {
*   await createProject("existingProject");
* } catch (error) {
*   if (error instanceof ConflictError) {
*     console.log("A conflict occurred:", error.message);
*     // Handle the conflict, e.g., by suggesting a different project name
*   } else {
*     // Handle other types of errors
*   }
* }
*
* @property {string} name - Always set to 'ConflictError' for easy identification
* @property {string} message - Detailed error message including server response
*
* @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/409
*/
var LangSmithConflictError = class extends Error {
	constructor(message) {
		super(message);
		Object.defineProperty(this, "status", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.name = "LangSmithConflictError";
		this.status = 409;
	}
};
/**
* Throws an appropriate error based on the response status and body.
*
* @param response - The fetch Response object
* @param context - Additional context to include in the error message (e.g., operation being performed)
* @throws {LangSmithConflictError} When the response status is 409
* @throws {Error} For all other non-ok responses
*/
async function raiseForStatus(response, context, consume) {
	let errorBody;
	if (response.ok) {
		if (consume) errorBody = await response.text();
		return;
	}
	errorBody = await response.text();
	const fullMessage = `Failed to ${context}. Received status [${response.status}]: ${response.statusText}. Server response: ${errorBody}`;
	if (response.status === 409) throw new LangSmithConflictError(fullMessage);
	const err = new Error(fullMessage);
	err.status = response.status;
	throw err;
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/utils/fast-safe-stringify/index.js
var LIMIT_REPLACE_NODE = "[...]";
var CIRCULAR_REPLACE_NODE = { result: "[Circular]" };
var arr = [];
var replacerStack = [];
const encoder = new TextEncoder();
function defaultOptions$1() {
	return {
		depthLimit: Number.MAX_SAFE_INTEGER,
		edgesLimit: Number.MAX_SAFE_INTEGER
	};
}
function encodeString(str) {
	return encoder.encode(str);
}
function serialize(obj, errorContext, replacer, spacer, options) {
	try {
		const str = JSON.stringify(obj, replacer, spacer);
		return encodeString(str);
	} catch (e) {
		if (!e.message?.includes("Converting circular structure to JSON")) {
			console.warn(`[WARNING]: LangSmith received unserializable value.${errorContext ? `\nContext: ${errorContext}` : ""}`);
			return encodeString("[Unserializable]");
		}
		console.warn(`[WARNING]: LangSmith received circular JSON. This will decrease tracer performance. ${errorContext ? `\nContext: ${errorContext}` : ""}`);
		if (typeof options === "undefined") options = defaultOptions$1();
		decirc(obj, "", 0, [], void 0, 0, options);
		let res;
		try {
			if (replacerStack.length === 0) res = JSON.stringify(obj, replacer, spacer);
			else res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
		} catch (_) {
			return encodeString("[unable to serialize, circular reference is too complex to analyze]");
		} finally {
			while (arr.length !== 0) {
				const part = arr.pop();
				if (part.length === 4) Object.defineProperty(part[0], part[1], part[3]);
				else part[0][part[1]] = part[2];
			}
		}
		return encodeString(res);
	}
}
function setReplace(replace, val, k, parent) {
	var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
	if (propertyDescriptor.get !== void 0) if (propertyDescriptor.configurable) {
		Object.defineProperty(parent, k, { value: replace });
		arr.push([
			parent,
			k,
			val,
			propertyDescriptor
		]);
	} else replacerStack.push([
		val,
		k,
		replace
	]);
	else {
		parent[k] = replace;
		arr.push([
			parent,
			k,
			val
		]);
	}
}
function decirc(val, k, edgeIndex, stack, parent, depth, options) {
	depth += 1;
	var i;
	if (typeof val === "object" && val !== null) {
		for (i = 0; i < stack.length; i++) if (stack[i] === val) {
			setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
			return;
		}
		if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
			setReplace(LIMIT_REPLACE_NODE, val, k, parent);
			return;
		}
		if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
			setReplace(LIMIT_REPLACE_NODE, val, k, parent);
			return;
		}
		stack.push(val);
		if (Array.isArray(val)) for (i = 0; i < val.length; i++) decirc(val[i], i, i, stack, val, depth, options);
		else {
			var keys = Object.keys(val);
			for (i = 0; i < keys.length; i++) {
				var key = keys[i];
				decirc(val[key], key, i, stack, val, depth, options);
			}
		}
		stack.pop();
	}
}
function replaceGetterValues(replacer) {
	replacer = typeof replacer !== "undefined" ? replacer : function(k, v) {
		return v;
	};
	return function(key, val) {
		if (replacerStack.length > 0) for (var i = 0; i < replacerStack.length; i++) {
			var part = replacerStack[i];
			if (part[1] === key && part[0] === val) {
				val = part[2];
				replacerStack.splice(i, 1);
				break;
			}
		}
		return replacer.call(this, key, val);
	};
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/client.js
function mergeRuntimeEnvIntoRunCreate(run) {
	const runtimeEnv = getRuntimeEnvironment$1();
	const envVars = getLangChainEnvVarsMetadata();
	const extra = run.extra ?? {};
	const metadata = extra.metadata;
	run.extra = {
		...extra,
		runtime: {
			...runtimeEnv,
			...extra?.runtime
		},
		metadata: {
			...envVars,
			...envVars.revision_id || run.revision_id ? { revision_id: run.revision_id ?? envVars.revision_id } : {},
			...metadata
		}
	};
	return run;
}
const getTracingSamplingRate = (configRate) => {
	const samplingRateStr = configRate?.toString() ?? getLangSmithEnvironmentVariable("TRACING_SAMPLING_RATE");
	if (samplingRateStr === void 0) return void 0;
	const samplingRate = parseFloat(samplingRateStr);
	if (samplingRate < 0 || samplingRate > 1) throw new Error(`LANGSMITH_TRACING_SAMPLING_RATE must be between 0 and 1 if set. Got: ${samplingRate}`);
	return samplingRate;
};
const isLocalhost = (url) => {
	const strippedUrl = url.replace("http://", "").replace("https://", "");
	const hostname = strippedUrl.split("/")[0].split(":")[0];
	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
};
async function toArray(iterable) {
	const result = [];
	for await (const item of iterable) result.push(item);
	return result;
}
function trimQuotes(str) {
	if (str === void 0) return void 0;
	return str.trim().replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
}
const handle429 = async (response) => {
	if (response?.status === 429) {
		const retryAfter = parseInt(response.headers.get("retry-after") ?? "30", 10) * 1e3;
		if (retryAfter > 0) {
			await new Promise((resolve) => setTimeout(resolve, retryAfter));
			return true;
		}
	}
	return false;
};
function _formatFeedbackScore(score) {
	if (typeof score === "number") return Number(score.toFixed(4));
	return score;
}
var AutoBatchQueue = class {
	constructor() {
		Object.defineProperty(this, "items", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "sizeBytes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: 0
		});
	}
	peek() {
		return this.items[0];
	}
	push(item) {
		let itemPromiseResolve;
		const itemPromise = new Promise((resolve) => {
			itemPromiseResolve = resolve;
		});
		const size = serialize(item.item, `Serializing run with id: ${item.item.id}`).length;
		this.items.push({
			action: item.action,
			payload: item.item,
			itemPromiseResolve,
			itemPromise,
			size
		});
		this.sizeBytes += size;
		return itemPromise;
	}
	pop(upToSizeBytes) {
		if (upToSizeBytes < 1) throw new Error("Number of bytes to pop off may not be less than 1.");
		const popped = [];
		let poppedSizeBytes = 0;
		while (poppedSizeBytes + (this.peek()?.size ?? 0) < upToSizeBytes && this.items.length > 0) {
			const item = this.items.shift();
			if (item) {
				popped.push(item);
				poppedSizeBytes += item.size;
				this.sizeBytes -= item.size;
			}
		}
		if (popped.length === 0 && this.items.length > 0) {
			const item = this.items.shift();
			popped.push(item);
			poppedSizeBytes += item.size;
			this.sizeBytes -= item.size;
		}
		return [popped.map((it) => ({
			action: it.action,
			item: it.payload
		})), () => popped.forEach((it) => it.itemPromiseResolve())];
	}
};
const DEFAULT_BATCH_SIZE_LIMIT_BYTES = 20971520;
const SERVER_INFO_REQUEST_TIMEOUT = 2500;
var Client = class Client {
	constructor(config = {}) {
		Object.defineProperty(this, "apiKey", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "apiUrl", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "webUrl", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "caller", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "batchIngestCaller", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "timeout_ms", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "_tenantId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: null
		});
		Object.defineProperty(this, "hideInputs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "hideOutputs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "tracingSampleRate", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "filteredPostUuids", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: /* @__PURE__ */ new Set()
		});
		Object.defineProperty(this, "autoBatchTracing", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "autoBatchQueue", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: new AutoBatchQueue()
		});
		Object.defineProperty(this, "autoBatchTimeout", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "autoBatchAggregationDelayMs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: 250
		});
		Object.defineProperty(this, "batchSizeBytesLimit", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "fetchOptions", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "settings", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "blockOnRootRunFinalization", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: getEnvironmentVariable$1("LANGSMITH_TRACING_BACKGROUND") === "false"
		});
		Object.defineProperty(this, "traceBatchConcurrency", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: 5
		});
		Object.defineProperty(this, "_serverInfo", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "_getServerInfoPromise", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "manualFlushMode", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "debug", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: getEnvironmentVariable$1("LANGSMITH_DEBUG") === "true"
		});
		const defaultConfig = Client.getDefaultClientConfig();
		this.tracingSampleRate = getTracingSamplingRate(config.tracingSamplingRate);
		this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
		if (this.apiUrl.endsWith("/")) this.apiUrl = this.apiUrl.slice(0, -1);
		this.apiKey = trimQuotes(config.apiKey ?? defaultConfig.apiKey);
		this.webUrl = trimQuotes(config.webUrl ?? defaultConfig.webUrl);
		if (this.webUrl?.endsWith("/")) this.webUrl = this.webUrl.slice(0, -1);
		this.timeout_ms = config.timeout_ms ?? 9e4;
		this.caller = new AsyncCaller$1({
			...config.callerOptions ?? {},
			debug: config.debug ?? this.debug
		});
		this.traceBatchConcurrency = config.traceBatchConcurrency ?? this.traceBatchConcurrency;
		if (this.traceBatchConcurrency < 1) throw new Error("Trace batch concurrency must be positive.");
		this.debug = config.debug ?? this.debug;
		this.batchIngestCaller = new AsyncCaller$1({
			maxRetries: 2,
			maxConcurrency: this.traceBatchConcurrency,
			...config.callerOptions ?? {},
			onFailedResponseHook: handle429,
			debug: config.debug ?? this.debug
		});
		this.hideInputs = config.hideInputs ?? config.anonymizer ?? defaultConfig.hideInputs;
		this.hideOutputs = config.hideOutputs ?? config.anonymizer ?? defaultConfig.hideOutputs;
		this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
		this.blockOnRootRunFinalization = config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
		this.batchSizeBytesLimit = config.batchSizeBytesLimit;
		this.fetchOptions = config.fetchOptions || {};
		this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
	}
	static getDefaultClientConfig() {
		const apiKey = getLangSmithEnvironmentVariable("API_KEY");
		const apiUrl = getLangSmithEnvironmentVariable("ENDPOINT") ?? "https://api.smith.langchain.com";
		const hideInputs = getLangSmithEnvironmentVariable("HIDE_INPUTS") === "true";
		const hideOutputs = getLangSmithEnvironmentVariable("HIDE_OUTPUTS") === "true";
		return {
			apiUrl,
			apiKey,
			webUrl: void 0,
			hideInputs,
			hideOutputs
		};
	}
	getHostUrl() {
		if (this.webUrl) return this.webUrl;
		else if (isLocalhost(this.apiUrl)) {
			this.webUrl = "http://localhost:3000";
			return this.webUrl;
		} else if (this.apiUrl.endsWith("/api/v1")) {
			this.webUrl = this.apiUrl.replace("/api/v1", "");
			return this.webUrl;
		} else if (this.apiUrl.includes("/api") && !this.apiUrl.split(".", 1)[0].endsWith("api")) {
			this.webUrl = this.apiUrl.replace("/api", "");
			return this.webUrl;
		} else if (this.apiUrl.split(".", 1)[0].includes("dev")) {
			this.webUrl = "https://dev.smith.langchain.com";
			return this.webUrl;
		} else if (this.apiUrl.split(".", 1)[0].includes("eu")) {
			this.webUrl = "https://eu.smith.langchain.com";
			return this.webUrl;
		} else if (this.apiUrl.split(".", 1)[0].includes("beta")) {
			this.webUrl = "https://beta.smith.langchain.com";
			return this.webUrl;
		} else {
			this.webUrl = "https://smith.langchain.com";
			return this.webUrl;
		}
	}
	get headers() {
		const headers = { "User-Agent": `langsmith-js/${__version__}` };
		if (this.apiKey) headers["x-api-key"] = `${this.apiKey}`;
		return headers;
	}
	async processInputs(inputs) {
		if (this.hideInputs === false) return inputs;
		if (this.hideInputs === true) return {};
		if (typeof this.hideInputs === "function") return this.hideInputs(inputs);
		return inputs;
	}
	async processOutputs(outputs) {
		if (this.hideOutputs === false) return outputs;
		if (this.hideOutputs === true) return {};
		if (typeof this.hideOutputs === "function") return this.hideOutputs(outputs);
		return outputs;
	}
	async prepareRunCreateOrUpdateInputs(run) {
		const runParams = { ...run };
		if (runParams.inputs !== void 0) runParams.inputs = await this.processInputs(runParams.inputs);
		if (runParams.outputs !== void 0) runParams.outputs = await this.processOutputs(runParams.outputs);
		return runParams;
	}
	async _getResponse(path, queryParams) {
		const paramsString = queryParams?.toString() ?? "";
		const url = `${this.apiUrl}${path}?${paramsString}`;
		const response = await this.caller.call(_getFetchImplementation(this.debug), url, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, `Failed to fetch ${path}`);
		return response;
	}
	async _get(path, queryParams) {
		const response = await this._getResponse(path, queryParams);
		return response.json();
	}
	async *_getPaginated(path, queryParams = new URLSearchParams(), transform) {
		let offset = Number(queryParams.get("offset")) || 0;
		const limit = Number(queryParams.get("limit")) || 100;
		while (true) {
			queryParams.set("offset", String(offset));
			queryParams.set("limit", String(limit));
			const url = `${this.apiUrl}${path}?${queryParams}`;
			const response = await this.caller.call(_getFetchImplementation(this.debug), url, {
				method: "GET",
				headers: this.headers,
				signal: AbortSignal.timeout(this.timeout_ms),
				...this.fetchOptions
			});
			await raiseForStatus(response, `Failed to fetch ${path}`);
			const items = transform ? transform(await response.json()) : await response.json();
			if (items.length === 0) break;
			yield items;
			if (items.length < limit) break;
			offset += items.length;
		}
	}
	async *_getCursorPaginatedList(path, body = null, requestMethod = "POST", dataKey = "runs") {
		const bodyParams = body ? { ...body } : {};
		while (true) {
			const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}${path}`, {
				method: requestMethod,
				headers: {
					...this.headers,
					"Content-Type": "application/json"
				},
				signal: AbortSignal.timeout(this.timeout_ms),
				...this.fetchOptions,
				body: JSON.stringify(bodyParams)
			});
			const responseBody = await response.json();
			if (!responseBody) break;
			if (!responseBody[dataKey]) break;
			yield responseBody[dataKey];
			const cursors = responseBody.cursors;
			if (!cursors) break;
			if (!cursors.next) break;
			bodyParams.cursor = cursors.next;
		}
	}
	_shouldSample() {
		if (this.tracingSampleRate === void 0) return true;
		return Math.random() < this.tracingSampleRate;
	}
	_filterForSampling(runs, patch$2 = false) {
		if (this.tracingSampleRate === void 0) return runs;
		if (patch$2) {
			const sampled = [];
			for (const run of runs) if (!this.filteredPostUuids.has(run.id)) sampled.push(run);
			else this.filteredPostUuids.delete(run.id);
			return sampled;
		} else {
			const sampled = [];
			for (const run of runs) {
				const traceId = run.trace_id ?? run.id;
				if (this.filteredPostUuids.has(traceId)) continue;
				if (run.id === traceId) if (this._shouldSample()) sampled.push(run);
				else this.filteredPostUuids.add(traceId);
				else sampled.push(run);
			}
			return sampled;
		}
	}
	async _getBatchSizeLimitBytes() {
		const serverInfo = await this._ensureServerInfo();
		return this.batchSizeBytesLimit ?? serverInfo.batch_ingest_config?.size_limit_bytes ?? DEFAULT_BATCH_SIZE_LIMIT_BYTES;
	}
	async _getMultiPartSupport() {
		const serverInfo = await this._ensureServerInfo();
		return serverInfo.instance_flags?.dataset_examples_multipart_enabled ?? false;
	}
	drainAutoBatchQueue(batchSizeLimit) {
		const promises = [];
		while (this.autoBatchQueue.items.length > 0) {
			const [batch, done] = this.autoBatchQueue.pop(batchSizeLimit);
			if (!batch.length) {
				done();
				break;
			}
			const batchPromise = this._processBatch(batch, done).catch(console.error);
			promises.push(batchPromise);
		}
		return Promise.all(promises);
	}
	async _processBatch(batch, done) {
		if (!batch.length) {
			done();
			return;
		}
		try {
			const ingestParams = {
				runCreates: batch.filter((item) => item.action === "create").map((item) => item.item),
				runUpdates: batch.filter((item) => item.action === "update").map((item) => item.item)
			};
			const serverInfo = await this._ensureServerInfo();
			if (serverInfo?.batch_ingest_config?.use_multipart_endpoint) await this.multipartIngestRuns(ingestParams);
			else await this.batchIngestRuns(ingestParams);
		} finally {
			done();
		}
	}
	async processRunOperation(item) {
		clearTimeout(this.autoBatchTimeout);
		this.autoBatchTimeout = void 0;
		if (item.action === "create") item.item = mergeRuntimeEnvIntoRunCreate(item.item);
		const itemPromise = this.autoBatchQueue.push(item);
		if (this.manualFlushMode) return itemPromise;
		const sizeLimitBytes = await this._getBatchSizeLimitBytes();
		if (this.autoBatchQueue.sizeBytes > sizeLimitBytes) this.drainAutoBatchQueue(sizeLimitBytes);
		if (this.autoBatchQueue.items.length > 0) this.autoBatchTimeout = setTimeout(() => {
			this.autoBatchTimeout = void 0;
			this.drainAutoBatchQueue(sizeLimitBytes);
		}, this.autoBatchAggregationDelayMs);
		return itemPromise;
	}
	async _getServerInfo() {
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/info`, {
			method: "GET",
			headers: { Accept: "application/json" },
			signal: AbortSignal.timeout(SERVER_INFO_REQUEST_TIMEOUT),
			...this.fetchOptions
		});
		await raiseForStatus(response, "get server info");
		const json = await response.json();
		if (this.debug) console.log("\n=== LangSmith Server Configuration ===\n" + JSON.stringify(json, null, 2) + "\n");
		return json;
	}
	async _ensureServerInfo() {
		if (this._getServerInfoPromise === void 0) this._getServerInfoPromise = (async () => {
			if (this._serverInfo === void 0) try {
				this._serverInfo = await this._getServerInfo();
			} catch (e) {
				console.warn(`[WARNING]: LangSmith failed to fetch info on supported operations with status code ${e.status}. Falling back to batch operations and default limits.`);
			}
			return this._serverInfo ?? {};
		})();
		return this._getServerInfoPromise.then((serverInfo) => {
			if (this._serverInfo === void 0) this._getServerInfoPromise = void 0;
			return serverInfo;
		});
	}
	async _getSettings() {
		if (!this.settings) this.settings = this._get("/settings");
		return await this.settings;
	}
	/**
	* Flushes current queued traces.
	*/
	async flush() {
		const sizeLimitBytes = await this._getBatchSizeLimitBytes();
		await this.drainAutoBatchQueue(sizeLimitBytes);
	}
	async createRun(run) {
		if (!this._filterForSampling([run]).length) return;
		const headers = {
			...this.headers,
			"Content-Type": "application/json"
		};
		const session_name = run.project_name;
		delete run.project_name;
		const runCreate = await this.prepareRunCreateOrUpdateInputs({
			session_name,
			...run,
			start_time: run.start_time ?? Date.now()
		});
		if (this.autoBatchTracing && runCreate.trace_id !== void 0 && runCreate.dotted_order !== void 0) {
			this.processRunOperation({
				action: "create",
				item: runCreate
			}).catch(console.error);
			return;
		}
		const mergedRunCreateParam = mergeRuntimeEnvIntoRunCreate(runCreate);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs`, {
			method: "POST",
			headers,
			body: serialize(mergedRunCreateParam, `Creating run with id: ${mergedRunCreateParam.id}`),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create run", true);
	}
	/**
	* Batch ingest/upsert multiple runs in the Langsmith system.
	* @param runs
	*/
	async batchIngestRuns({ runCreates, runUpdates }) {
		if (runCreates === void 0 && runUpdates === void 0) return;
		let preparedCreateParams = await Promise.all(runCreates?.map((create) => this.prepareRunCreateOrUpdateInputs(create)) ?? []);
		let preparedUpdateParams = await Promise.all(runUpdates?.map((update) => this.prepareRunCreateOrUpdateInputs(update)) ?? []);
		if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) {
			const createById = preparedCreateParams.reduce((params, run) => {
				if (!run.id) return params;
				params[run.id] = run;
				return params;
			}, {});
			const standaloneUpdates = [];
			for (const updateParam of preparedUpdateParams) if (updateParam.id !== void 0 && createById[updateParam.id]) createById[updateParam.id] = {
				...createById[updateParam.id],
				...updateParam
			};
			else standaloneUpdates.push(updateParam);
			preparedCreateParams = Object.values(createById);
			preparedUpdateParams = standaloneUpdates;
		}
		const rawBatch = {
			post: preparedCreateParams,
			patch: preparedUpdateParams
		};
		if (!rawBatch.post.length && !rawBatch.patch.length) return;
		const batchChunks = {
			post: [],
			patch: []
		};
		for (const k of ["post", "patch"]) {
			const key = k;
			const batchItems = rawBatch[key].reverse();
			let batchItem = batchItems.pop();
			while (batchItem !== void 0) {
				batchChunks[key].push(batchItem);
				batchItem = batchItems.pop();
			}
		}
		if (batchChunks.post.length > 0 || batchChunks.patch.length > 0) {
			const runIds = batchChunks.post.map((item) => item.id).concat(batchChunks.patch.map((item) => item.id)).join(",");
			await this._postBatchIngestRuns(serialize(batchChunks, `Ingesting runs with ids: ${runIds}`));
		}
	}
	async _postBatchIngestRuns(body) {
		const headers = {
			...this.headers,
			"Content-Type": "application/json",
			Accept: "application/json"
		};
		const response = await this.batchIngestCaller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/batch`, {
			method: "POST",
			headers,
			body,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "batch create run", true);
	}
	/**
	* Batch ingest/upsert multiple runs in the Langsmith system.
	* @param runs
	*/
	async multipartIngestRuns({ runCreates, runUpdates }) {
		if (runCreates === void 0 && runUpdates === void 0) return;
		const allAttachments = {};
		let preparedCreateParams = [];
		for (const create of runCreates ?? []) {
			const preparedCreate = await this.prepareRunCreateOrUpdateInputs(create);
			if (preparedCreate.id !== void 0 && preparedCreate.attachments !== void 0) allAttachments[preparedCreate.id] = preparedCreate.attachments;
			delete preparedCreate.attachments;
			preparedCreateParams.push(preparedCreate);
		}
		let preparedUpdateParams = [];
		for (const update of runUpdates ?? []) preparedUpdateParams.push(await this.prepareRunCreateOrUpdateInputs(update));
		const invalidRunCreate = preparedCreateParams.find((runCreate) => {
			return runCreate.trace_id === void 0 || runCreate.dotted_order === void 0;
		});
		if (invalidRunCreate !== void 0) throw new Error(`Multipart ingest requires "trace_id" and "dotted_order" to be set when creating a run`);
		const invalidRunUpdate = preparedUpdateParams.find((runUpdate) => {
			return runUpdate.trace_id === void 0 || runUpdate.dotted_order === void 0;
		});
		if (invalidRunUpdate !== void 0) throw new Error(`Multipart ingest requires "trace_id" and "dotted_order" to be set when updating a run`);
		if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) {
			const createById = preparedCreateParams.reduce((params, run) => {
				if (!run.id) return params;
				params[run.id] = run;
				return params;
			}, {});
			const standaloneUpdates = [];
			for (const updateParam of preparedUpdateParams) if (updateParam.id !== void 0 && createById[updateParam.id]) createById[updateParam.id] = {
				...createById[updateParam.id],
				...updateParam
			};
			else standaloneUpdates.push(updateParam);
			preparedCreateParams = Object.values(createById);
			preparedUpdateParams = standaloneUpdates;
		}
		if (preparedCreateParams.length === 0 && preparedUpdateParams.length === 0) return;
		const accumulatedContext = [];
		const accumulatedParts = [];
		for (const [method, payloads] of [["post", preparedCreateParams], ["patch", preparedUpdateParams]]) for (const originalPayload of payloads) {
			const { inputs, outputs, events, attachments,...payload } = originalPayload;
			const fields = {
				inputs,
				outputs,
				events
			};
			const stringifiedPayload = serialize(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
			accumulatedParts.push({
				name: `${method}.${payload.id}`,
				payload: new Blob([stringifiedPayload], { type: `application/json; length=${stringifiedPayload.length}` })
			});
			for (const [key, value] of Object.entries(fields)) {
				if (value === void 0) continue;
				const stringifiedValue = serialize(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
				accumulatedParts.push({
					name: `${method}.${payload.id}.${key}`,
					payload: new Blob([stringifiedValue], { type: `application/json; length=${stringifiedValue.length}` })
				});
			}
			if (payload.id !== void 0) {
				const attachments$1 = allAttachments[payload.id];
				if (attachments$1) {
					delete allAttachments[payload.id];
					for (const [name, attachment] of Object.entries(attachments$1)) {
						let contentType;
						let content;
						if (Array.isArray(attachment)) [contentType, content] = attachment;
						else {
							contentType = attachment.mimeType;
							content = attachment.data;
						}
						if (name.includes(".")) {
							console.warn(`Skipping attachment '${name}' for run ${payload.id}: Invalid attachment name. Attachment names must not contain periods ('.'). Please rename the attachment and try again.`);
							continue;
						}
						accumulatedParts.push({
							name: `attachment.${payload.id}.${name}`,
							payload: new Blob([content], { type: `${contentType}; length=${content.byteLength}` })
						});
					}
				}
			}
			accumulatedContext.push(`trace=${payload.trace_id},id=${payload.id}`);
		}
		await this._sendMultipartRequest(accumulatedParts, accumulatedContext.join("; "));
	}
	async _createNodeFetchBody(parts, boundary) {
		const chunks = [];
		for (const part of parts) {
			chunks.push(new Blob([`--${boundary}\r\n`]));
			chunks.push(new Blob([`Content-Disposition: form-data; name="${part.name}"\r\n`, `Content-Type: ${part.payload.type}\r\n\r\n`]));
			chunks.push(part.payload);
			chunks.push(new Blob(["\r\n"]));
		}
		chunks.push(new Blob([`--${boundary}--\r\n`]));
		const body = new Blob(chunks);
		const arrayBuffer = await body.arrayBuffer();
		return arrayBuffer;
	}
	async _createMultipartStream(parts, boundary) {
		const encoder$1 = new TextEncoder();
		const stream = new ReadableStream({ async start(controller) {
			const writeChunk = async (chunk) => {
				if (typeof chunk === "string") controller.enqueue(encoder$1.encode(chunk));
				else controller.enqueue(chunk);
			};
			for (const part of parts) {
				await writeChunk(`--${boundary}\r\n`);
				await writeChunk(`Content-Disposition: form-data; name="${part.name}"\r\n`);
				await writeChunk(`Content-Type: ${part.payload.type}\r\n\r\n`);
				const payloadStream = part.payload.stream();
				const reader = payloadStream.getReader();
				try {
					let result;
					while (!(result = await reader.read()).done) controller.enqueue(result.value);
				} finally {
					reader.releaseLock();
				}
				await writeChunk("\r\n");
			}
			await writeChunk(`--${boundary}--\r\n`);
			controller.close();
		} });
		return stream;
	}
	async _sendMultipartRequest(parts, context) {
		try {
			const boundary = "----LangSmithFormBoundary" + Math.random().toString(36).slice(2);
			const body = await (_globalFetchImplementationIsNodeFetch() ? this._createNodeFetchBody(parts, boundary) : this._createMultipartStream(parts, boundary));
			const res = await this.batchIngestCaller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/multipart`, {
				method: "POST",
				headers: {
					...this.headers,
					"Content-Type": `multipart/form-data; boundary=${boundary}`
				},
				body,
				duplex: "half",
				signal: AbortSignal.timeout(this.timeout_ms),
				...this.fetchOptions
			});
			await raiseForStatus(res, "ingest multipart runs", true);
		} catch (e) {
			console.warn(`${e.message.trim()}\n\nContext: ${context}`);
		}
	}
	async updateRun(runId, run) {
		assertUuid(runId);
		if (run.inputs) run.inputs = await this.processInputs(run.inputs);
		if (run.outputs) run.outputs = await this.processOutputs(run.outputs);
		const data = {
			...run,
			id: runId
		};
		if (!this._filterForSampling([data], true).length) return;
		if (this.autoBatchTracing && data.trace_id !== void 0 && data.dotted_order !== void 0) {
			if (run.end_time !== void 0 && data.parent_run_id === void 0 && this.blockOnRootRunFinalization && !this.manualFlushMode) {
				await this.processRunOperation({
					action: "update",
					item: data
				}).catch(console.error);
				return;
			} else this.processRunOperation({
				action: "update",
				item: data
			}).catch(console.error);
			return;
		}
		const headers = {
			...this.headers,
			"Content-Type": "application/json"
		};
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/${runId}`, {
			method: "PATCH",
			headers,
			body: serialize(run, `Serializing payload to update run with id: ${runId}`),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update run", true);
	}
	async readRun(runId, { loadChildRuns } = { loadChildRuns: false }) {
		assertUuid(runId);
		let run = await this._get(`/runs/${runId}`);
		if (loadChildRuns) run = await this._loadChildRuns(run);
		return run;
	}
	async getRunUrl({ runId, run, projectOpts }) {
		if (run !== void 0) {
			let sessionId;
			if (run.session_id) sessionId = run.session_id;
			else if (projectOpts?.projectName) sessionId = (await this.readProject({ projectName: projectOpts?.projectName })).id;
			else if (projectOpts?.projectId) sessionId = projectOpts?.projectId;
			else {
				const project = await this.readProject({ projectName: getLangSmithEnvironmentVariable("PROJECT") || "default" });
				sessionId = project.id;
			}
			const tenantId = await this._getTenantId();
			return `${this.getHostUrl()}/o/${tenantId}/projects/p/${sessionId}/r/${run.id}?poll=true`;
		} else if (runId !== void 0) {
			const run_ = await this.readRun(runId);
			if (!run_.app_path) throw new Error(`Run ${runId} has no app_path`);
			const baseUrl = this.getHostUrl();
			return `${baseUrl}${run_.app_path}`;
		} else throw new Error("Must provide either runId or run");
	}
	async _loadChildRuns(run) {
		const childRuns = await toArray(this.listRuns({
			isRoot: false,
			projectId: run.session_id,
			traceId: run.trace_id
		}));
		const treemap = {};
		const runs = {};
		childRuns.sort((a, b) => (a?.dotted_order ?? "").localeCompare(b?.dotted_order ?? ""));
		for (const childRun of childRuns) {
			if (childRun.parent_run_id === null || childRun.parent_run_id === void 0) throw new Error(`Child run ${childRun.id} has no parent`);
			if (childRun.dotted_order?.startsWith(run.dotted_order ?? "") && childRun.id !== run.id) {
				if (!(childRun.parent_run_id in treemap)) treemap[childRun.parent_run_id] = [];
				treemap[childRun.parent_run_id].push(childRun);
				runs[childRun.id] = childRun;
			}
		}
		run.child_runs = treemap[run.id] || [];
		for (const runId in treemap) if (runId !== run.id) runs[runId].child_runs = treemap[runId];
		return run;
	}
	/**
	* List runs from the LangSmith server.
	* @param projectId - The ID of the project to filter by.
	* @param projectName - The name of the project to filter by.
	* @param parentRunId - The ID of the parent run to filter by.
	* @param traceId - The ID of the trace to filter by.
	* @param referenceExampleId - The ID of the reference example to filter by.
	* @param startTime - The start time to filter by.
	* @param isRoot - Indicates whether to only return root runs.
	* @param runType - The run type to filter by.
	* @param error - Indicates whether to filter by error runs.
	* @param id - The ID of the run to filter by.
	* @param query - The query string to filter by.
	* @param filter - The filter string to apply to the run spans.
	* @param traceFilter - The filter string to apply on the root run of the trace.
	* @param treeFilter - The filter string to apply on other runs in the trace.
	* @param limit - The maximum number of runs to retrieve.
	* @returns {AsyncIterable<Run>} - The runs.
	*
	* @example
	* // List all runs in a project
	* const projectRuns = client.listRuns({ projectName: "<your_project>" });
	*
	* @example
	* // List LLM and Chat runs in the last 24 hours
	* const todaysLLMRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   start_time: new Date(Date.now() - 24 * 60 * 60 * 1000),
	*   run_type: "llm",
	* });
	*
	* @example
	* // List traces in a project
	* const rootRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   execution_order: 1,
	* });
	*
	* @example
	* // List runs without errors
	* const correctRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   error: false,
	* });
	*
	* @example
	* // List runs by run ID
	* const runIds = [
	*   "a36092d2-4ad5-4fb4-9c0d-0dba9a2ed836",
	*   "9398e6be-964f-4aa4-8ae9-ad78cd4b7074",
	* ];
	* const selectedRuns = client.listRuns({ run_ids: runIds });
	*
	* @example
	* // List all "chain" type runs that took more than 10 seconds and had `total_tokens` greater than 5000
	* const chainRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   filter: 'and(eq(run_type, "chain"), gt(latency, 10), gt(total_tokens, 5000))',
	* });
	*
	* @example
	* // List all runs called "extractor" whose root of the trace was assigned feedback "user_score" score of 1
	* const goodExtractorRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   filter: 'eq(name, "extractor")',
	*   traceFilter: 'and(eq(feedback_key, "user_score"), eq(feedback_score, 1))',
	* });
	*
	* @example
	* // List all runs that started after a specific timestamp and either have "error" not equal to null or a "Correctness" feedback score equal to 0
	* const complexRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   filter: 'and(gt(start_time, "2023-07-15T12:34:56Z"), or(neq(error, null), and(eq(feedback_key, "Correctness"), eq(feedback_score, 0.0))))',
	* });
	*
	* @example
	* // List all runs where `tags` include "experimental" or "beta" and `latency` is greater than 2 seconds
	* const taggedRuns = client.listRuns({
	*   projectName: "<your_project>",
	*   filter: 'and(or(has(tags, "experimental"), has(tags, "beta")), gt(latency, 2))',
	* });
	*/
	async *listRuns(props) {
		const { projectId, projectName, parentRunId, traceId, referenceExampleId, startTime, executionOrder, isRoot, runType, error, id, query, filter, traceFilter, treeFilter, limit, select, order } = props;
		let projectIds = [];
		if (projectId) projectIds = Array.isArray(projectId) ? projectId : [projectId];
		if (projectName) {
			const projectNames = Array.isArray(projectName) ? projectName : [projectName];
			const projectIds_ = await Promise.all(projectNames.map((name) => this.readProject({ projectName: name }).then((project) => project.id)));
			projectIds.push(...projectIds_);
		}
		const default_select = [
			"app_path",
			"completion_cost",
			"completion_tokens",
			"dotted_order",
			"end_time",
			"error",
			"events",
			"extra",
			"feedback_stats",
			"first_token_time",
			"id",
			"inputs",
			"name",
			"outputs",
			"parent_run_id",
			"parent_run_ids",
			"prompt_cost",
			"prompt_tokens",
			"reference_example_id",
			"run_type",
			"session_id",
			"start_time",
			"status",
			"tags",
			"total_cost",
			"total_tokens",
			"trace_id"
		];
		const body = {
			session: projectIds.length ? projectIds : null,
			run_type: runType,
			reference_example: referenceExampleId,
			query,
			filter,
			trace_filter: traceFilter,
			tree_filter: treeFilter,
			execution_order: executionOrder,
			parent_run: parentRunId,
			start_time: startTime ? startTime.toISOString() : null,
			error,
			id,
			limit,
			trace: traceId,
			select: select ? select : default_select,
			is_root: isRoot,
			order
		};
		let runsYielded = 0;
		for await (const runs of this._getCursorPaginatedList("/runs/query", body)) if (limit) {
			if (runsYielded >= limit) break;
			if (runs.length + runsYielded > limit) {
				const newRuns = runs.slice(0, limit - runsYielded);
				yield* newRuns;
				break;
			}
			runsYielded += runs.length;
			yield* runs;
		} else yield* runs;
	}
	async *listGroupRuns(props) {
		const { projectId, projectName, groupBy, filter, startTime, endTime, limit, offset } = props;
		const sessionId = projectId || (await this.readProject({ projectName })).id;
		const baseBody = {
			session_id: sessionId,
			group_by: groupBy,
			filter,
			start_time: startTime ? startTime.toISOString() : null,
			end_time: endTime ? endTime.toISOString() : null,
			limit: Number(limit) || 100
		};
		let currentOffset = Number(offset) || 0;
		const path = "/runs/group";
		const url = `${this.apiUrl}${path}`;
		while (true) {
			const currentBody = {
				...baseBody,
				offset: currentOffset
			};
			const filteredPayload = Object.fromEntries(Object.entries(currentBody).filter(([_, value]) => value !== void 0));
			const response = await this.caller.call(_getFetchImplementation(), url, {
				method: "POST",
				headers: {
					...this.headers,
					"Content-Type": "application/json"
				},
				body: JSON.stringify(filteredPayload),
				signal: AbortSignal.timeout(this.timeout_ms),
				...this.fetchOptions
			});
			await raiseForStatus(response, `Failed to fetch ${path}`);
			const items = await response.json();
			const { groups, total } = items;
			if (groups.length === 0) break;
			for (const thread of groups) yield thread;
			currentOffset += groups.length;
			if (currentOffset >= total) break;
		}
	}
	async getRunStats({ id, trace, parentRun, runType, projectNames, projectIds, referenceExampleIds, startTime, endTime, error, query, filter, traceFilter, treeFilter, isRoot, dataSourceType }) {
		let projectIds_ = projectIds || [];
		if (projectNames) projectIds_ = [...projectIds || [], ...await Promise.all(projectNames.map((name) => this.readProject({ projectName: name }).then((project) => project.id)))];
		const payload = {
			id,
			trace,
			parent_run: parentRun,
			run_type: runType,
			session: projectIds_,
			reference_example: referenceExampleIds,
			start_time: startTime,
			end_time: endTime,
			error,
			query,
			filter,
			trace_filter: traceFilter,
			tree_filter: treeFilter,
			is_root: isRoot,
			data_source_type: dataSourceType
		};
		const filteredPayload = Object.fromEntries(Object.entries(payload).filter(([_, value]) => value !== void 0));
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/stats`, {
			method: "POST",
			headers: this.headers,
			body: JSON.stringify(filteredPayload),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const result = await response.json();
		return result;
	}
	async shareRun(runId, { shareId } = {}) {
		const data = {
			run_id: runId,
			share_token: shareId || v4_default()
		};
		assertUuid(runId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/${runId}/share`, {
			method: "PUT",
			headers: this.headers,
			body: JSON.stringify(data),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const result = await response.json();
		if (result === null || !("share_token" in result)) throw new Error("Invalid response from server");
		return `${this.getHostUrl()}/public/${result["share_token"]}/r`;
	}
	async unshareRun(runId) {
		assertUuid(runId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/${runId}/share`, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "unshare run", true);
	}
	async readRunSharedLink(runId) {
		assertUuid(runId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/runs/${runId}/share`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const result = await response.json();
		if (result === null || !("share_token" in result)) return void 0;
		return `${this.getHostUrl()}/public/${result["share_token"]}/r`;
	}
	async listSharedRuns(shareToken, { runIds } = {}) {
		const queryParams = new URLSearchParams({ share_token: shareToken });
		if (runIds !== void 0) for (const runId of runIds) queryParams.append("id", runId);
		assertUuid(shareToken);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/public/${shareToken}/runs${queryParams}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const runs = await response.json();
		return runs;
	}
	async readDatasetSharedSchema(datasetId, datasetName) {
		if (!datasetId && !datasetName) throw new Error("Either datasetId or datasetName must be given");
		if (!datasetId) {
			const dataset = await this.readDataset({ datasetName });
			datasetId = dataset.id;
		}
		assertUuid(datasetId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${datasetId}/share`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const shareSchema = await response.json();
		shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`;
		return shareSchema;
	}
	async shareDataset(datasetId, datasetName) {
		if (!datasetId && !datasetName) throw new Error("Either datasetId or datasetName must be given");
		if (!datasetId) {
			const dataset = await this.readDataset({ datasetName });
			datasetId = dataset.id;
		}
		const data = { dataset_id: datasetId };
		assertUuid(datasetId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${datasetId}/share`, {
			method: "PUT",
			headers: this.headers,
			body: JSON.stringify(data),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const shareSchema = await response.json();
		shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`;
		return shareSchema;
	}
	async unshareDataset(datasetId) {
		assertUuid(datasetId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${datasetId}/share`, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "unshare dataset", true);
	}
	async readSharedDataset(shareToken) {
		assertUuid(shareToken);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/public/${shareToken}/datasets`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const dataset = await response.json();
		return dataset;
	}
	/**
	* Get shared examples.
	*
	* @param {string} shareToken The share token to get examples for. A share token is the UUID (or LangSmith URL, including UUID) generated when explicitly marking an example as public.
	* @param {Object} [options] Additional options for listing the examples.
	* @param {string[] | undefined} [options.exampleIds] A list of example IDs to filter by.
	* @returns {Promise<Example[]>} The shared examples.
	*/
	async listSharedExamples(shareToken, options) {
		const params = {};
		if (options?.exampleIds) params.id = options.exampleIds;
		const urlParams = new URLSearchParams();
		Object.entries(params).forEach(([key, value]) => {
			if (Array.isArray(value)) value.forEach((v) => urlParams.append(key, v));
			else urlParams.append(key, value);
		});
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/public/${shareToken}/examples?${urlParams.toString()}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const result = await response.json();
		if (!response.ok) {
			if ("detail" in result) throw new Error(`Failed to list shared examples.\nStatus: ${response.status}\nMessage: ${Array.isArray(result.detail) ? result.detail.join("\n") : "Unspecified error"}`);
			throw new Error(`Failed to list shared examples: ${response.status} ${response.statusText}`);
		}
		return result.map((example) => ({
			...example,
			_hostUrl: this.getHostUrl()
		}));
	}
	async createProject({ projectName, description = null, metadata = null, upsert = false, projectExtra = null, referenceDatasetId = null }) {
		const upsert_ = upsert ? `?upsert=true` : "";
		const endpoint = `${this.apiUrl}/sessions${upsert_}`;
		const extra = projectExtra || {};
		if (metadata) extra["metadata"] = metadata;
		const body = {
			name: projectName,
			extra,
			description
		};
		if (referenceDatasetId !== null) body["reference_dataset_id"] = referenceDatasetId;
		const response = await this.caller.call(_getFetchImplementation(this.debug), endpoint, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(body),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create project");
		const result = await response.json();
		return result;
	}
	async updateProject(projectId, { name = null, description = null, metadata = null, projectExtra = null, endTime = null }) {
		const endpoint = `${this.apiUrl}/sessions/${projectId}`;
		let extra = projectExtra;
		if (metadata) extra = {
			...extra || {},
			metadata
		};
		const body = {
			name,
			extra,
			description,
			end_time: endTime ? new Date(endTime).toISOString() : null
		};
		const response = await this.caller.call(_getFetchImplementation(this.debug), endpoint, {
			method: "PATCH",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(body),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update project");
		const result = await response.json();
		return result;
	}
	async hasProject({ projectId, projectName }) {
		let path = "/sessions";
		const params = new URLSearchParams();
		if (projectId !== void 0 && projectName !== void 0) throw new Error("Must provide either projectName or projectId, not both");
		else if (projectId !== void 0) {
			assertUuid(projectId);
			path += `/${projectId}`;
		} else if (projectName !== void 0) params.append("name", projectName);
		else throw new Error("Must provide projectName or projectId");
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}${path}?${params}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		try {
			const result = await response.json();
			if (!response.ok) return false;
			if (Array.isArray(result)) return result.length > 0;
			return true;
		} catch (e) {
			return false;
		}
	}
	async readProject({ projectId, projectName, includeStats }) {
		let path = "/sessions";
		const params = new URLSearchParams();
		if (projectId !== void 0 && projectName !== void 0) throw new Error("Must provide either projectName or projectId, not both");
		else if (projectId !== void 0) {
			assertUuid(projectId);
			path += `/${projectId}`;
		} else if (projectName !== void 0) params.append("name", projectName);
		else throw new Error("Must provide projectName or projectId");
		if (includeStats !== void 0) params.append("include_stats", includeStats.toString());
		const response = await this._get(path, params);
		let result;
		if (Array.isArray(response)) {
			if (response.length === 0) throw new Error(`Project[id=${projectId}, name=${projectName}] not found`);
			result = response[0];
		} else result = response;
		return result;
	}
	async getProjectUrl({ projectId, projectName }) {
		if (projectId === void 0 && projectName === void 0) throw new Error("Must provide either projectName or projectId");
		const project = await this.readProject({
			projectId,
			projectName
		});
		const tenantId = await this._getTenantId();
		return `${this.getHostUrl()}/o/${tenantId}/projects/p/${project.id}`;
	}
	async getDatasetUrl({ datasetId, datasetName }) {
		if (datasetId === void 0 && datasetName === void 0) throw new Error("Must provide either datasetName or datasetId");
		const dataset = await this.readDataset({
			datasetId,
			datasetName
		});
		const tenantId = await this._getTenantId();
		return `${this.getHostUrl()}/o/${tenantId}/datasets/${dataset.id}`;
	}
	async _getTenantId() {
		if (this._tenantId !== null) return this._tenantId;
		const queryParams = new URLSearchParams({ limit: "1" });
		for await (const projects of this._getPaginated("/sessions", queryParams)) {
			this._tenantId = projects[0].tenant_id;
			return projects[0].tenant_id;
		}
		throw new Error("No projects found to resolve tenant.");
	}
	async *listProjects({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, referenceFree, metadata } = {}) {
		const params = new URLSearchParams();
		if (projectIds !== void 0) for (const projectId of projectIds) params.append("id", projectId);
		if (name !== void 0) params.append("name", name);
		if (nameContains !== void 0) params.append("name_contains", nameContains);
		if (referenceDatasetId !== void 0) params.append("reference_dataset", referenceDatasetId);
		else if (referenceDatasetName !== void 0) {
			const dataset = await this.readDataset({ datasetName: referenceDatasetName });
			params.append("reference_dataset", dataset.id);
		}
		if (referenceFree !== void 0) params.append("reference_free", referenceFree.toString());
		if (metadata !== void 0) params.append("metadata", JSON.stringify(metadata));
		for await (const projects of this._getPaginated("/sessions", params)) yield* projects;
	}
	async deleteProject({ projectId, projectName }) {
		let projectId_;
		if (projectId === void 0 && projectName === void 0) throw new Error("Must provide projectName or projectId");
		else if (projectId !== void 0 && projectName !== void 0) throw new Error("Must provide either projectName or projectId, not both");
		else if (projectId === void 0) projectId_ = (await this.readProject({ projectName })).id;
		else projectId_ = projectId;
		assertUuid(projectId_);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/sessions/${projectId_}`, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, `delete session ${projectId_} (${projectName})`, true);
	}
	async uploadCsv({ csvFile, fileName, inputKeys, outputKeys, description, dataType, name }) {
		const url = `${this.apiUrl}/datasets/upload`;
		const formData = new FormData();
		formData.append("file", csvFile, fileName);
		inputKeys.forEach((key) => {
			formData.append("input_keys", key);
		});
		outputKeys.forEach((key) => {
			formData.append("output_keys", key);
		});
		if (description) formData.append("description", description);
		if (dataType) formData.append("data_type", dataType);
		if (name) formData.append("name", name);
		const response = await this.caller.call(_getFetchImplementation(this.debug), url, {
			method: "POST",
			headers: this.headers,
			body: formData,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "upload CSV");
		const result = await response.json();
		return result;
	}
	async createDataset(name, { description, dataType, inputsSchema, outputsSchema, metadata } = {}) {
		const body = {
			name,
			description,
			extra: metadata ? { metadata } : void 0
		};
		if (dataType) body.data_type = dataType;
		if (inputsSchema) body.inputs_schema_definition = inputsSchema;
		if (outputsSchema) body.outputs_schema_definition = outputsSchema;
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(body),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create dataset");
		const result = await response.json();
		return result;
	}
	async readDataset({ datasetId, datasetName }) {
		let path = "/datasets";
		const params = new URLSearchParams({ limit: "1" });
		if (datasetId !== void 0 && datasetName !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId !== void 0) {
			assertUuid(datasetId);
			path += `/${datasetId}`;
		} else if (datasetName !== void 0) params.append("name", datasetName);
		else throw new Error("Must provide datasetName or datasetId");
		const response = await this._get(path, params);
		let result;
		if (Array.isArray(response)) {
			if (response.length === 0) throw new Error(`Dataset[id=${datasetId}, name=${datasetName}] not found`);
			result = response[0];
		} else result = response;
		return result;
	}
	async hasDataset({ datasetId, datasetName }) {
		try {
			await this.readDataset({
				datasetId,
				datasetName
			});
			return true;
		} catch (e) {
			if (e instanceof Error && e.message.toLocaleLowerCase().includes("not found")) return false;
			throw e;
		}
	}
	async diffDatasetVersions({ datasetId, datasetName, fromVersion, toVersion }) {
		let datasetId_ = datasetId;
		if (datasetId_ === void 0 && datasetName === void 0) throw new Error("Must provide either datasetName or datasetId");
		else if (datasetId_ !== void 0 && datasetName !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId_ === void 0) {
			const dataset = await this.readDataset({ datasetName });
			datasetId_ = dataset.id;
		}
		const urlParams = new URLSearchParams({
			from_version: typeof fromVersion === "string" ? fromVersion : fromVersion.toISOString(),
			to_version: typeof toVersion === "string" ? toVersion : toVersion.toISOString()
		});
		const response = await this._get(`/datasets/${datasetId_}/versions/diff`, urlParams);
		return response;
	}
	async readDatasetOpenaiFinetuning({ datasetId, datasetName }) {
		const path = "/datasets";
		if (datasetId !== void 0) {} else if (datasetName !== void 0) datasetId = (await this.readDataset({ datasetName })).id;
		else throw new Error("Must provide either datasetName or datasetId");
		const response = await this._getResponse(`${path}/${datasetId}/openai_ft`);
		const datasetText = await response.text();
		const dataset = datasetText.trim().split("\n").map((line) => JSON.parse(line));
		return dataset;
	}
	async *listDatasets({ limit = 100, offset = 0, datasetIds, datasetName, datasetNameContains, metadata } = {}) {
		const path = "/datasets";
		const params = new URLSearchParams({
			limit: limit.toString(),
			offset: offset.toString()
		});
		if (datasetIds !== void 0) for (const id_ of datasetIds) params.append("id", id_);
		if (datasetName !== void 0) params.append("name", datasetName);
		if (datasetNameContains !== void 0) params.append("name_contains", datasetNameContains);
		if (metadata !== void 0) params.append("metadata", JSON.stringify(metadata));
		for await (const datasets of this._getPaginated(path, params)) yield* datasets;
	}
	/**
	* Update a dataset
	* @param props The dataset details to update
	* @returns The updated dataset
	*/
	async updateDataset(props) {
		const { datasetId, datasetName,...update } = props;
		if (!datasetId && !datasetName) throw new Error("Must provide either datasetName or datasetId");
		const _datasetId = datasetId ?? (await this.readDataset({ datasetName })).id;
		assertUuid(_datasetId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${_datasetId}`, {
			method: "PATCH",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(update),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update dataset");
		return await response.json();
	}
	/**
	* Updates a tag on a dataset.
	*
	* If the tag is already assigned to a different version of this dataset,
	* the tag will be moved to the new version. The as_of parameter is used to
	* determine which version of the dataset to apply the new tags to.
	*
	* It must be an exact version of the dataset to succeed. You can
	* use the "readDatasetVersion" method to find the exact version
	* to apply the tags to.
	* @param params.datasetId The ID of the dataset to update. Must be provided if "datasetName" is not provided.
	* @param params.datasetName The name of the dataset to update. Must be provided if "datasetId" is not provided.
	* @param params.asOf The timestamp of the dataset to apply the new tags to.
	* @param params.tag The new tag to apply to the dataset.
	*/
	async updateDatasetTag(props) {
		const { datasetId, datasetName, asOf, tag } = props;
		if (!datasetId && !datasetName) throw new Error("Must provide either datasetName or datasetId");
		const _datasetId = datasetId ?? (await this.readDataset({ datasetName })).id;
		assertUuid(_datasetId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${_datasetId}/tags`, {
			method: "PUT",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify({
				as_of: typeof asOf === "string" ? asOf : asOf.toISOString(),
				tag
			}),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update dataset tags");
	}
	async deleteDataset({ datasetId, datasetName }) {
		let path = "/datasets";
		let datasetId_ = datasetId;
		if (datasetId !== void 0 && datasetName !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetName !== void 0) {
			const dataset = await this.readDataset({ datasetName });
			datasetId_ = dataset.id;
		}
		if (datasetId_ !== void 0) {
			assertUuid(datasetId_);
			path += `/${datasetId_}`;
		} else throw new Error("Must provide datasetName or datasetId");
		const response = await this.caller.call(_getFetchImplementation(this.debug), this.apiUrl + path, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, `delete ${path}`);
		await response.json();
	}
	async indexDataset({ datasetId, datasetName, tag }) {
		let datasetId_ = datasetId;
		if (!datasetId_ && !datasetName) throw new Error("Must provide either datasetName or datasetId");
		else if (datasetId_ && datasetName) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (!datasetId_) {
			const dataset = await this.readDataset({ datasetName });
			datasetId_ = dataset.id;
		}
		assertUuid(datasetId_);
		const data = { tag };
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${datasetId_}/index`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(data),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "index dataset");
		await response.json();
	}
	/**
	* Lets you run a similarity search query on a dataset.
	*
	* Requires the dataset to be indexed. Please see the `indexDataset` method to set up indexing.
	*
	* @param inputs      The input on which to run the similarity search. Must have the
	*                    same schema as the dataset.
	*
	* @param datasetId   The dataset to search for similar examples.
	*
	* @param limit       The maximum number of examples to return. Will return the top `limit` most
	*                    similar examples in order of most similar to least similar. If no similar
	*                    examples are found, random examples will be returned.
	*
	* @param filter      A filter string to apply to the search. Only examples will be returned that
	*                    match the filter string. Some examples of filters
	*
	*                    - eq(metadata.mykey, "value")
	*                    - and(neq(metadata.my.nested.key, "value"), neq(metadata.mykey, "value"))
	*                    - or(eq(metadata.mykey, "value"), eq(metadata.mykey, "othervalue"))
	*
	* @returns           A list of similar examples.
	*
	*
	* @example
	* dataset_id = "123e4567-e89b-12d3-a456-426614174000"
	* inputs = {"text": "How many people live in Berlin?"}
	* limit = 5
	* examples = await client.similarExamples(inputs, dataset_id, limit)
	*/
	async similarExamples(inputs, datasetId, limit, { filter } = {}) {
		const data = {
			limit,
			inputs
		};
		if (filter !== void 0) data["filter"] = filter;
		assertUuid(datasetId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${datasetId}/search`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(data),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "fetch similar examples");
		const result = await response.json();
		return result["examples"];
	}
	async createExample(inputsOrUpdate, outputs, options) {
		if (isExampleCreate(inputsOrUpdate)) {
			if (outputs !== void 0 || options !== void 0) throw new Error("Cannot provide outputs or options when using ExampleCreate object");
		}
		let datasetId_ = outputs ? options?.datasetId : inputsOrUpdate.dataset_id;
		const datasetName_ = outputs ? options?.datasetName : inputsOrUpdate.dataset_name;
		if (datasetId_ === void 0 && datasetName_ === void 0) throw new Error("Must provide either datasetName or datasetId");
		else if (datasetId_ !== void 0 && datasetName_ !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId_ === void 0) {
			const dataset = await this.readDataset({ datasetName: datasetName_ });
			datasetId_ = dataset.id;
		}
		const createdAt_ = (outputs ? options?.createdAt : inputsOrUpdate.created_at) || /* @__PURE__ */ new Date();
		let data;
		if (!isExampleCreate(inputsOrUpdate)) data = {
			inputs: inputsOrUpdate,
			outputs,
			created_at: createdAt_?.toISOString(),
			id: options?.exampleId,
			metadata: options?.metadata,
			split: options?.split,
			source_run_id: options?.sourceRunId,
			use_source_run_io: options?.useSourceRunIO,
			use_source_run_attachments: options?.useSourceRunAttachments,
			attachments: options?.attachments
		};
		else data = inputsOrUpdate;
		const response = await this._uploadExamplesMultipart(datasetId_, [data]);
		const example = await this.readExample(response.example_ids?.[0] ?? v4_default());
		return example;
	}
	async createExamples(propsOrUploads) {
		if (Array.isArray(propsOrUploads)) {
			if (propsOrUploads.length === 0) return [];
			const uploads = propsOrUploads;
			let datasetId_$1 = uploads[0].dataset_id;
			const datasetName_$1 = uploads[0].dataset_name;
			if (datasetId_$1 === void 0 && datasetName_$1 === void 0) throw new Error("Must provide either datasetName or datasetId");
			else if (datasetId_$1 !== void 0 && datasetName_$1 !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
			else if (datasetId_$1 === void 0) {
				const dataset = await this.readDataset({ datasetName: datasetName_$1 });
				datasetId_$1 = dataset.id;
			}
			const response$1 = await this._uploadExamplesMultipart(datasetId_$1, uploads);
			const examples$1 = await Promise.all(response$1.example_ids.map((id) => this.readExample(id)));
			return examples$1;
		}
		const { inputs, outputs, metadata, splits, sourceRunIds, useSourceRunIOs, useSourceRunAttachments, attachments, exampleIds, datasetId, datasetName } = propsOrUploads;
		if (inputs === void 0) throw new Error("Must provide inputs when using legacy parameters");
		let datasetId_ = datasetId;
		const datasetName_ = datasetName;
		if (datasetId_ === void 0 && datasetName_ === void 0) throw new Error("Must provide either datasetName or datasetId");
		else if (datasetId_ !== void 0 && datasetName_ !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId_ === void 0) {
			const dataset = await this.readDataset({ datasetName: datasetName_ });
			datasetId_ = dataset.id;
		}
		const formattedExamples = inputs.map((input, idx) => {
			return {
				dataset_id: datasetId_,
				inputs: input,
				outputs: outputs?.[idx],
				metadata: metadata?.[idx],
				split: splits?.[idx],
				id: exampleIds?.[idx],
				attachments: attachments?.[idx],
				source_run_id: sourceRunIds?.[idx],
				use_source_run_io: useSourceRunIOs?.[idx],
				use_source_run_attachments: useSourceRunAttachments?.[idx]
			};
		});
		const response = await this._uploadExamplesMultipart(datasetId_, formattedExamples);
		const examples = await Promise.all(response.example_ids.map((id) => this.readExample(id)));
		return examples;
	}
	async createLLMExample(input, generation, options) {
		return this.createExample({ input }, { output: generation }, options);
	}
	async createChatExample(input, generations, options) {
		const finalInput = input.map((message) => {
			if (isLangChainMessage(message)) return convertLangChainMessageToExample(message);
			return message;
		});
		const finalOutput = isLangChainMessage(generations) ? convertLangChainMessageToExample(generations) : generations;
		return this.createExample({ input: finalInput }, { output: finalOutput }, options);
	}
	async readExample(exampleId) {
		assertUuid(exampleId);
		const path = `/examples/${exampleId}`;
		const rawExample = await this._get(path);
		const { attachment_urls,...rest } = rawExample;
		const example = rest;
		if (attachment_urls) example.attachments = Object.entries(attachment_urls).reduce((acc, [key, value]) => {
			acc[key.slice(11)] = {
				presigned_url: value.presigned_url,
				mime_type: value.mime_type
			};
			return acc;
		}, {});
		return example;
	}
	async *listExamples({ datasetId, datasetName, exampleIds, asOf, splits, inlineS3Urls, metadata, limit, offset, filter, includeAttachments } = {}) {
		let datasetId_;
		if (datasetId !== void 0 && datasetName !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId !== void 0) datasetId_ = datasetId;
		else if (datasetName !== void 0) {
			const dataset = await this.readDataset({ datasetName });
			datasetId_ = dataset.id;
		} else throw new Error("Must provide a datasetName or datasetId");
		const params = new URLSearchParams({ dataset: datasetId_ });
		const dataset_version = asOf ? typeof asOf === "string" ? asOf : asOf?.toISOString() : void 0;
		if (dataset_version) params.append("as_of", dataset_version);
		const inlineS3Urls_ = inlineS3Urls ?? true;
		params.append("inline_s3_urls", inlineS3Urls_.toString());
		if (exampleIds !== void 0) for (const id_ of exampleIds) params.append("id", id_);
		if (splits !== void 0) for (const split of splits) params.append("splits", split);
		if (metadata !== void 0) {
			const serializedMetadata = JSON.stringify(metadata);
			params.append("metadata", serializedMetadata);
		}
		if (limit !== void 0) params.append("limit", limit.toString());
		if (offset !== void 0) params.append("offset", offset.toString());
		if (filter !== void 0) params.append("filter", filter);
		if (includeAttachments === true) [
			"attachment_urls",
			"outputs",
			"metadata"
		].forEach((field) => params.append("select", field));
		let i = 0;
		for await (const rawExamples of this._getPaginated("/examples", params)) {
			for (const rawExample of rawExamples) {
				const { attachment_urls,...rest } = rawExample;
				const example = rest;
				if (attachment_urls) example.attachments = Object.entries(attachment_urls).reduce((acc, [key, value]) => {
					acc[key.slice(11)] = {
						presigned_url: value.presigned_url,
						mime_type: value.mime_type || void 0
					};
					return acc;
				}, {});
				yield example;
				i++;
			}
			if (limit !== void 0 && i >= limit) break;
		}
	}
	async deleteExample(exampleId) {
		assertUuid(exampleId);
		const path = `/examples/${exampleId}`;
		const response = await this.caller.call(_getFetchImplementation(this.debug), this.apiUrl + path, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, `delete ${path}`);
		await response.json();
	}
	async updateExample(exampleIdOrUpdate, update) {
		let exampleId;
		if (update) exampleId = exampleIdOrUpdate;
		else exampleId = exampleIdOrUpdate.id;
		assertUuid(exampleId);
		let updateToUse;
		if (update) updateToUse = {
			id: exampleId,
			...update
		};
		else updateToUse = exampleIdOrUpdate;
		let datasetId;
		if (updateToUse.dataset_id !== void 0) datasetId = updateToUse.dataset_id;
		else {
			const example = await this.readExample(exampleId);
			datasetId = example.dataset_id;
		}
		return this._updateExamplesMultipart(datasetId, [updateToUse]);
	}
	async updateExamples(update) {
		let datasetId;
		if (update[0].dataset_id === void 0) {
			const example = await this.readExample(update[0].id);
			datasetId = example.dataset_id;
		} else datasetId = update[0].dataset_id;
		return this._updateExamplesMultipart(datasetId, update);
	}
	/**
	* Get dataset version by closest date or exact tag.
	*
	* Use this to resolve the nearest version to a given timestamp or for a given tag.
	*
	* @param options The options for getting the dataset version
	* @param options.datasetId The ID of the dataset
	* @param options.datasetName The name of the dataset
	* @param options.asOf The timestamp of the dataset to retrieve
	* @param options.tag The tag of the dataset to retrieve
	* @returns The dataset version
	*/
	async readDatasetVersion({ datasetId, datasetName, asOf, tag }) {
		let resolvedDatasetId;
		if (!datasetId) {
			const dataset = await this.readDataset({ datasetName });
			resolvedDatasetId = dataset.id;
		} else resolvedDatasetId = datasetId;
		assertUuid(resolvedDatasetId);
		if (asOf && tag || !asOf && !tag) throw new Error("Exactly one of asOf and tag must be specified.");
		const params = new URLSearchParams();
		if (asOf !== void 0) params.append("as_of", typeof asOf === "string" ? asOf : asOf.toISOString());
		if (tag !== void 0) params.append("tag", tag);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${resolvedDatasetId}/version?${params.toString()}`, {
			method: "GET",
			headers: { ...this.headers },
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "read dataset version");
		return await response.json();
	}
	async listDatasetSplits({ datasetId, datasetName, asOf }) {
		let datasetId_;
		if (datasetId === void 0 && datasetName === void 0) throw new Error("Must provide dataset name or ID");
		else if (datasetId !== void 0 && datasetName !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId === void 0) {
			const dataset = await this.readDataset({ datasetName });
			datasetId_ = dataset.id;
		} else datasetId_ = datasetId;
		assertUuid(datasetId_);
		const params = new URLSearchParams();
		const dataset_version = asOf ? typeof asOf === "string" ? asOf : asOf?.toISOString() : void 0;
		if (dataset_version) params.append("as_of", dataset_version);
		const response = await this._get(`/datasets/${datasetId_}/splits`, params);
		return response;
	}
	async updateDatasetSplits({ datasetId, datasetName, splitName, exampleIds, remove = false }) {
		let datasetId_;
		if (datasetId === void 0 && datasetName === void 0) throw new Error("Must provide dataset name or ID");
		else if (datasetId !== void 0 && datasetName !== void 0) throw new Error("Must provide either datasetName or datasetId, not both");
		else if (datasetId === void 0) {
			const dataset = await this.readDataset({ datasetName });
			datasetId_ = dataset.id;
		} else datasetId_ = datasetId;
		assertUuid(datasetId_);
		const data = {
			split_name: splitName,
			examples: exampleIds.map((id) => {
				assertUuid(id);
				return id;
			}),
			remove
		};
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/${datasetId_}/splits`, {
			method: "PUT",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(data),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update dataset splits", true);
	}
	/**
	* @deprecated This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.
	*/
	async evaluateRun(run, evaluator, { sourceInfo, loadChildRuns, referenceExample } = { loadChildRuns: false }) {
		warnOnce("This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.");
		let run_;
		if (typeof run === "string") run_ = await this.readRun(run, { loadChildRuns });
		else if (typeof run === "object" && "id" in run) run_ = run;
		else throw new Error(`Invalid run type: ${typeof run}`);
		if (run_.reference_example_id !== null && run_.reference_example_id !== void 0) referenceExample = await this.readExample(run_.reference_example_id);
		const feedbackResult = await evaluator.evaluateRun(run_, referenceExample);
		const [_, feedbacks] = await this._logEvaluationFeedback(feedbackResult, run_, sourceInfo);
		return feedbacks[0];
	}
	async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId }) {
		if (!runId && !projectId) throw new Error("One of runId or projectId must be provided");
		if (runId && projectId) throw new Error("Only one of runId or projectId can be provided");
		const feedback_source = {
			type: feedbackSourceType ?? "api",
			metadata: sourceInfo ?? {}
		};
		if (sourceRunId !== void 0 && feedback_source?.metadata !== void 0 && !feedback_source.metadata["__run"]) feedback_source.metadata["__run"] = { run_id: sourceRunId };
		if (feedback_source?.metadata !== void 0 && feedback_source.metadata["__run"]?.run_id !== void 0) assertUuid(feedback_source.metadata["__run"].run_id);
		const feedback = {
			id: feedbackId ?? v4_default(),
			run_id: runId,
			key,
			score: _formatFeedbackScore(score),
			value,
			correction,
			comment,
			feedback_source,
			comparative_experiment_id: comparativeExperimentId,
			feedbackConfig,
			session_id: projectId
		};
		const url = `${this.apiUrl}/feedback`;
		const response = await this.caller.call(_getFetchImplementation(this.debug), url, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(feedback),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create feedback", true);
		return feedback;
	}
	async updateFeedback(feedbackId, { score, value, correction, comment }) {
		const feedbackUpdate = {};
		if (score !== void 0 && score !== null) feedbackUpdate["score"] = _formatFeedbackScore(score);
		if (value !== void 0 && value !== null) feedbackUpdate["value"] = value;
		if (correction !== void 0 && correction !== null) feedbackUpdate["correction"] = correction;
		if (comment !== void 0 && comment !== null) feedbackUpdate["comment"] = comment;
		assertUuid(feedbackId);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/feedback/${feedbackId}`, {
			method: "PATCH",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(feedbackUpdate),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update feedback", true);
	}
	async readFeedback(feedbackId) {
		assertUuid(feedbackId);
		const path = `/feedback/${feedbackId}`;
		const response = await this._get(path);
		return response;
	}
	async deleteFeedback(feedbackId) {
		assertUuid(feedbackId);
		const path = `/feedback/${feedbackId}`;
		const response = await this.caller.call(_getFetchImplementation(this.debug), this.apiUrl + path, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, `delete ${path}`);
		await response.json();
	}
	async *listFeedback({ runIds, feedbackKeys, feedbackSourceTypes } = {}) {
		const queryParams = new URLSearchParams();
		if (runIds) queryParams.append("run", runIds.join(","));
		if (feedbackKeys) for (const key of feedbackKeys) queryParams.append("key", key);
		if (feedbackSourceTypes) for (const type of feedbackSourceTypes) queryParams.append("source", type);
		for await (const feedbacks of this._getPaginated("/feedback", queryParams)) yield* feedbacks;
	}
	/**
	* Creates a presigned feedback token and URL.
	*
	* The token can be used to authorize feedback metrics without
	* needing an API key. This is useful for giving browser-based
	* applications the ability to submit feedback without needing
	* to expose an API key.
	*
	* @param runId The ID of the run.
	* @param feedbackKey The feedback key.
	* @param options Additional options for the token.
	* @param options.expiration The expiration time for the token.
	*
	* @returns A promise that resolves to a FeedbackIngestToken.
	*/
	async createPresignedFeedbackToken(runId, feedbackKey, { expiration, feedbackConfig } = {}) {
		const body = {
			run_id: runId,
			feedback_key: feedbackKey,
			feedback_config: feedbackConfig
		};
		if (expiration) {
			if (typeof expiration === "string") body["expires_at"] = expiration;
			else if (expiration?.hours || expiration?.minutes || expiration?.days) body["expires_in"] = expiration;
		} else body["expires_in"] = { hours: 3 };
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/feedback/tokens`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(body),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const result = await response.json();
		return result;
	}
	async createComparativeExperiment({ name, experimentIds, referenceDatasetId, createdAt, description, metadata, id }) {
		if (experimentIds.length === 0) throw new Error("At least one experiment is required");
		if (!referenceDatasetId) referenceDatasetId = (await this.readProject({ projectId: experimentIds[0] })).reference_dataset_id;
		if (!referenceDatasetId == null) throw new Error("A reference dataset is required");
		const body = {
			id,
			name,
			experiment_ids: experimentIds,
			reference_dataset_id: referenceDatasetId,
			description,
			created_at: (createdAt ?? /* @__PURE__ */ new Date())?.toISOString(),
			extra: {}
		};
		if (metadata) body.extra["metadata"] = metadata;
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/datasets/comparative`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(body),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		return await response.json();
	}
	/**
	* Retrieves a list of presigned feedback tokens for a given run ID.
	* @param runId The ID of the run.
	* @returns An async iterable of FeedbackIngestToken objects.
	*/
	async *listPresignedFeedbackTokens(runId) {
		assertUuid(runId);
		const params = new URLSearchParams({ run_id: runId });
		for await (const tokens of this._getPaginated("/feedback/tokens", params)) yield* tokens;
	}
	_selectEvalResults(results) {
		let results_;
		if ("results" in results) results_ = results.results;
		else if (Array.isArray(results)) results_ = results;
		else results_ = [results];
		return results_;
	}
	async _logEvaluationFeedback(evaluatorResponse, run, sourceInfo) {
		const evalResults = this._selectEvalResults(evaluatorResponse);
		const feedbacks = [];
		for (const res of evalResults) {
			let sourceInfo_ = sourceInfo || {};
			if (res.evaluatorInfo) sourceInfo_ = {
				...res.evaluatorInfo,
				...sourceInfo_
			};
			let runId_ = null;
			if (res.targetRunId) runId_ = res.targetRunId;
			else if (run) runId_ = run.id;
			feedbacks.push(await this.createFeedback(runId_, res.key, {
				score: res.score,
				value: res.value,
				comment: res.comment,
				correction: res.correction,
				sourceInfo: sourceInfo_,
				sourceRunId: res.sourceRunId,
				feedbackConfig: res.feedbackConfig,
				feedbackSourceType: "model"
			}));
		}
		return [evalResults, feedbacks];
	}
	async logEvaluationFeedback(evaluatorResponse, run, sourceInfo) {
		const [results] = await this._logEvaluationFeedback(evaluatorResponse, run, sourceInfo);
		return results;
	}
	/**
	* API for managing annotation queues
	*/
	/**
	* List the annotation queues on the LangSmith API.
	* @param options - The options for listing annotation queues
	* @param options.queueIds - The IDs of the queues to filter by
	* @param options.name - The name of the queue to filter by
	* @param options.nameContains - The substring that the queue name should contain
	* @param options.limit - The maximum number of queues to return
	* @returns An iterator of AnnotationQueue objects
	*/
	async *listAnnotationQueues(options = {}) {
		const { queueIds, name, nameContains, limit } = options;
		const params = new URLSearchParams();
		if (queueIds) queueIds.forEach((id, i) => {
			assertUuid(id, `queueIds[${i}]`);
			params.append("ids", id);
		});
		if (name) params.append("name", name);
		if (nameContains) params.append("name_contains", nameContains);
		params.append("limit", (limit !== void 0 ? Math.min(limit, 100) : 100).toString());
		let count = 0;
		for await (const queues of this._getPaginated("/annotation-queues", params)) {
			yield* queues;
			count++;
			if (limit !== void 0 && count >= limit) break;
		}
	}
	/**
	* Create an annotation queue on the LangSmith API.
	* @param options - The options for creating an annotation queue
	* @param options.name - The name of the annotation queue
	* @param options.description - The description of the annotation queue
	* @param options.queueId - The ID of the annotation queue
	* @returns The created AnnotationQueue object
	*/
	async createAnnotationQueue(options) {
		const { name, description, queueId, rubricInstructions } = options;
		const body = {
			name,
			description,
			id: queueId || v4_default(),
			rubric_instructions: rubricInstructions
		};
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(Object.fromEntries(Object.entries(body).filter(([_, v]) => v !== void 0))),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create annotation queue");
		const data = await response.json();
		return data;
	}
	/**
	* Read an annotation queue with the specified queue ID.
	* @param queueId - The ID of the annotation queue to read
	* @returns The AnnotationQueueWithDetails object
	*/
	async readAnnotationQueue(queueId) {
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "read annotation queue");
		const data = await response.json();
		return data;
	}
	/**
	* Update an annotation queue with the specified queue ID.
	* @param queueId - The ID of the annotation queue to update
	* @param options - The options for updating the annotation queue
	* @param options.name - The new name for the annotation queue
	* @param options.description - The new description for the annotation queue
	*/
	async updateAnnotationQueue(queueId, options) {
		const { name, description, rubricInstructions } = options;
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
			method: "PATCH",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify({
				name,
				description,
				rubric_instructions: rubricInstructions
			}),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update annotation queue");
	}
	/**
	* Delete an annotation queue with the specified queue ID.
	* @param queueId - The ID of the annotation queue to delete
	*/
	async deleteAnnotationQueue(queueId) {
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
			method: "DELETE",
			headers: {
				...this.headers,
				Accept: "application/json"
			},
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "delete annotation queue");
	}
	/**
	* Add runs to an annotation queue with the specified queue ID.
	* @param queueId - The ID of the annotation queue
	* @param runIds - The IDs of the runs to be added to the annotation queue
	*/
	async addRunsToAnnotationQueue(queueId, runIds) {
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(runIds.map((id, i) => assertUuid(id, `runIds[${i}]`).toString())),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "add runs to annotation queue");
	}
	/**
	* Get a run from an annotation queue at the specified index.
	* @param queueId - The ID of the annotation queue
	* @param index - The index of the run to retrieve
	* @returns A Promise that resolves to a RunWithAnnotationQueueInfo object
	* @throws {Error} If the run is not found at the given index or for other API-related errors
	*/
	async getRunFromAnnotationQueue(queueId, index) {
		const baseUrl = `/annotation-queues/${assertUuid(queueId, "queueId")}/run`;
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}${baseUrl}/${index}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "get run from annotation queue");
		return await response.json();
	}
	/**
	* Delete a run from an an annotation queue.
	* @param queueId - The ID of the annotation queue to delete the run from
	* @param queueRunId - The ID of the run to delete from the annotation queue
	*/
	async deleteRunFromAnnotationQueue(queueId, queueRunId) {
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs/${assertUuid(queueRunId, "queueRunId")}`, {
			method: "DELETE",
			headers: {
				...this.headers,
				Accept: "application/json"
			},
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "delete run from annotation queue");
	}
	/**
	* Get the size of an annotation queue.
	* @param queueId - The ID of the annotation queue
	*/
	async getSizeFromAnnotationQueue(queueId) {
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/size`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "get size from annotation queue");
		return await response.json();
	}
	async _currentTenantIsOwner(owner) {
		const settings = await this._getSettings();
		return owner == "-" || settings.tenant_handle === owner;
	}
	async _ownerConflictError(action, owner) {
		const settings = await this._getSettings();
		return new Error(`Cannot ${action} for another tenant.\n
      Current tenant: ${settings.tenant_handle}\n
      Requested tenant: ${owner}`);
	}
	async _getLatestCommitHash(promptOwnerAndName) {
		const res = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/commits/${promptOwnerAndName}/?limit=1&offset=0`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		const json = await res.json();
		if (!res.ok) {
			const detail = typeof json.detail === "string" ? json.detail : JSON.stringify(json.detail);
			const error = new Error(`Error ${res.status}: ${res.statusText}\n${detail}`);
			error.statusCode = res.status;
			throw error;
		}
		if (json.commits.length === 0) return void 0;
		return json.commits[0].commit_hash;
	}
	async _likeOrUnlikePrompt(promptIdentifier, like) {
		const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/likes/${owner}/${promptName}`, {
			method: "POST",
			body: JSON.stringify({ like }),
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, `${like ? "like" : "unlike"} prompt`);
		return await response.json();
	}
	async _getPromptUrl(promptIdentifier) {
		const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
		if (!await this._currentTenantIsOwner(owner)) if (commitHash !== "latest") return `${this.getHostUrl()}/hub/${owner}/${promptName}/${commitHash.substring(0, 8)}`;
		else return `${this.getHostUrl()}/hub/${owner}/${promptName}`;
		else {
			const settings = await this._getSettings();
			if (commitHash !== "latest") return `${this.getHostUrl()}/prompts/${promptName}/${commitHash.substring(0, 8)}?organizationId=${settings.id}`;
			else return `${this.getHostUrl()}/prompts/${promptName}?organizationId=${settings.id}`;
		}
	}
	async promptExists(promptIdentifier) {
		const prompt = await this.getPrompt(promptIdentifier);
		return !!prompt;
	}
	async likePrompt(promptIdentifier) {
		return this._likeOrUnlikePrompt(promptIdentifier, true);
	}
	async unlikePrompt(promptIdentifier) {
		return this._likeOrUnlikePrompt(promptIdentifier, false);
	}
	async *listCommits(promptOwnerAndName) {
		for await (const commits of this._getPaginated(`/commits/${promptOwnerAndName}/`, new URLSearchParams(), (res) => res.commits)) yield* commits;
	}
	async *listPrompts(options) {
		const params = new URLSearchParams();
		params.append("sort_field", options?.sortField ?? "updated_at");
		params.append("sort_direction", "desc");
		params.append("is_archived", (!!options?.isArchived).toString());
		if (options?.isPublic !== void 0) params.append("is_public", options.isPublic.toString());
		if (options?.query) params.append("query", options.query);
		for await (const prompts of this._getPaginated("/repos", params, (res) => res.repos)) yield* prompts;
	}
	async getPrompt(promptIdentifier) {
		const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/repos/${owner}/${promptName}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		if (response.status === 404) return null;
		await raiseForStatus(response, "get prompt");
		const result = await response.json();
		if (result.repo) return result.repo;
		else return null;
	}
	async createPrompt(promptIdentifier, options) {
		const settings = await this._getSettings();
		if (options?.isPublic && !settings.tenant_handle) throw new Error(`Cannot create a public prompt without first\n
        creating a LangChain Hub handle. 
        You can add a handle by creating a public prompt at:\n
        https://smith.langchain.com/prompts`);
		const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
		if (!await this._currentTenantIsOwner(owner)) throw await this._ownerConflictError("create a prompt", owner);
		const data = {
			repo_handle: promptName,
			...options?.description && { description: options.description },
			...options?.readme && { readme: options.readme },
			...options?.tags && { tags: options.tags },
			is_public: !!options?.isPublic
		};
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/repos/`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(data),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create prompt");
		const { repo } = await response.json();
		return repo;
	}
	async createCommit(promptIdentifier, object, options) {
		if (!await this.promptExists(promptIdentifier)) throw new Error("Prompt does not exist, you must create it first.");
		const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
		const resolvedParentCommitHash = options?.parentCommitHash === "latest" || !options?.parentCommitHash ? await this._getLatestCommitHash(`${owner}/${promptName}`) : options?.parentCommitHash;
		const payload = {
			manifest: JSON.parse(JSON.stringify(object)),
			parent_commit: resolvedParentCommitHash
		};
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/commits/${owner}/${promptName}`, {
			method: "POST",
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			body: JSON.stringify(payload),
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "create commit");
		const result = await response.json();
		return this._getPromptUrl(`${owner}/${promptName}${result.commit_hash ? `:${result.commit_hash}` : ""}`);
	}
	/**
	* Update examples with attachments using multipart form data.
	* @param updates List of ExampleUpdateWithAttachments objects to upsert
	* @returns Promise with the update response
	*/
	async updateExamplesMultipart(datasetId, updates = []) {
		return this._updateExamplesMultipart(datasetId, updates);
	}
	async _updateExamplesMultipart(datasetId, updates = []) {
		if (!await this._getMultiPartSupport()) throw new Error("Your LangSmith deployment does not allow using the multipart examples endpoint, please upgrade your deployment to the latest version.");
		const formData = new FormData();
		for (const example of updates) {
			const exampleId = example.id;
			const exampleBody = {
				...example.metadata && { metadata: example.metadata },
				...example.split && { split: example.split }
			};
			const stringifiedExample = serialize(exampleBody, `Serializing body for example with id: ${exampleId}`);
			const exampleBlob = new Blob([stringifiedExample], { type: "application/json" });
			formData.append(exampleId, exampleBlob);
			if (example.inputs) {
				const stringifiedInputs = serialize(example.inputs, `Serializing inputs for example with id: ${exampleId}`);
				const inputsBlob = new Blob([stringifiedInputs], { type: "application/json" });
				formData.append(`${exampleId}.inputs`, inputsBlob);
			}
			if (example.outputs) {
				const stringifiedOutputs = serialize(example.outputs, `Serializing outputs whle updating example with id: ${exampleId}`);
				const outputsBlob = new Blob([stringifiedOutputs], { type: "application/json" });
				formData.append(`${exampleId}.outputs`, outputsBlob);
			}
			if (example.attachments) for (const [name, attachment] of Object.entries(example.attachments)) {
				let mimeType;
				let data;
				if (Array.isArray(attachment)) [mimeType, data] = attachment;
				else {
					mimeType = attachment.mimeType;
					data = attachment.data;
				}
				const attachmentBlob = new Blob([data], { type: `${mimeType}; length=${data.byteLength}` });
				formData.append(`${exampleId}.attachment.${name}`, attachmentBlob);
			}
			if (example.attachments_operations) {
				const stringifiedAttachmentsOperations = serialize(example.attachments_operations, `Serializing attachments while updating example with id: ${exampleId}`);
				const attachmentsOperationsBlob = new Blob([stringifiedAttachmentsOperations], { type: "application/json" });
				formData.append(`${exampleId}.attachments_operations`, attachmentsOperationsBlob);
			}
		}
		const datasetIdToUse = datasetId ?? updates[0]?.dataset_id;
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/v1/platform/datasets/${datasetIdToUse}/examples`, {
			method: "PATCH",
			headers: this.headers,
			body: formData
		});
		const result = await response.json();
		return result;
	}
	/**
	* Upload examples with attachments using multipart form data.
	* @param uploads List of ExampleUploadWithAttachments objects to upload
	* @returns Promise with the upload response
	* @deprecated This method is deprecated and will be removed in future LangSmith versions, please use `createExamples` instead
	*/
	async uploadExamplesMultipart(datasetId, uploads = []) {
		return this._uploadExamplesMultipart(datasetId, uploads);
	}
	async _uploadExamplesMultipart(datasetId, uploads = []) {
		if (!await this._getMultiPartSupport()) throw new Error("Your LangSmith deployment does not allow using the multipart examples endpoint, please upgrade your deployment to the latest version.");
		const formData = new FormData();
		for (const example of uploads) {
			const exampleId = (example.id ?? v4_default()).toString();
			const exampleBody = {
				created_at: example.created_at,
				...example.metadata && { metadata: example.metadata },
				...example.split && { split: example.split },
				...example.source_run_id && { source_run_id: example.source_run_id },
				...example.use_source_run_io && { use_source_run_io: example.use_source_run_io },
				...example.use_source_run_attachments && { use_source_run_attachments: example.use_source_run_attachments }
			};
			const stringifiedExample = serialize(exampleBody, `Serializing body for uploaded example with id: ${exampleId}`);
			const exampleBlob = new Blob([stringifiedExample], { type: "application/json" });
			formData.append(exampleId, exampleBlob);
			if (example.inputs) {
				const stringifiedInputs = serialize(example.inputs, `Serializing inputs for uploaded example with id: ${exampleId}`);
				const inputsBlob = new Blob([stringifiedInputs], { type: "application/json" });
				formData.append(`${exampleId}.inputs`, inputsBlob);
			}
			if (example.outputs) {
				const stringifiedOutputs = serialize(example.outputs, `Serializing outputs for uploaded example with id: ${exampleId}`);
				const outputsBlob = new Blob([stringifiedOutputs], { type: "application/json" });
				formData.append(`${exampleId}.outputs`, outputsBlob);
			}
			if (example.attachments) for (const [name, attachment] of Object.entries(example.attachments)) {
				let mimeType;
				let data;
				if (Array.isArray(attachment)) [mimeType, data] = attachment;
				else {
					mimeType = attachment.mimeType;
					data = attachment.data;
				}
				const attachmentBlob = new Blob([data], { type: `${mimeType}; length=${data.byteLength}` });
				formData.append(`${exampleId}.attachment.${name}`, attachmentBlob);
			}
		}
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/v1/platform/datasets/${datasetId}/examples`, {
			method: "POST",
			headers: this.headers,
			body: formData
		});
		await raiseForStatus(response, "upload examples");
		const result = await response.json();
		return result;
	}
	async updatePrompt(promptIdentifier, options) {
		if (!await this.promptExists(promptIdentifier)) throw new Error("Prompt does not exist, you must create it first.");
		const [owner, promptName] = parsePromptIdentifier(promptIdentifier);
		if (!await this._currentTenantIsOwner(owner)) throw await this._ownerConflictError("update a prompt", owner);
		const payload = {};
		if (options?.description !== void 0) payload.description = options.description;
		if (options?.readme !== void 0) payload.readme = options.readme;
		if (options?.tags !== void 0) payload.tags = options.tags;
		if (options?.isPublic !== void 0) payload.is_public = options.isPublic;
		if (options?.isArchived !== void 0) payload.is_archived = options.isArchived;
		if (Object.keys(payload).length === 0) throw new Error("No valid update options provided");
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/repos/${owner}/${promptName}`, {
			method: "PATCH",
			body: JSON.stringify(payload),
			headers: {
				...this.headers,
				"Content-Type": "application/json"
			},
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "update prompt");
		return response.json();
	}
	async deletePrompt(promptIdentifier) {
		if (!await this.promptExists(promptIdentifier)) throw new Error("Prompt does not exist, you must create it first.");
		const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
		if (!await this._currentTenantIsOwner(owner)) throw await this._ownerConflictError("delete a prompt", owner);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/repos/${owner}/${promptName}`, {
			method: "DELETE",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		return await response.json();
	}
	async pullPromptCommit(promptIdentifier, options) {
		const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
		const response = await this.caller.call(_getFetchImplementation(this.debug), `${this.apiUrl}/commits/${owner}/${promptName}/${commitHash}${options?.includeModel ? "?include_model=true" : ""}`, {
			method: "GET",
			headers: this.headers,
			signal: AbortSignal.timeout(this.timeout_ms),
			...this.fetchOptions
		});
		await raiseForStatus(response, "pull prompt commit");
		const result = await response.json();
		return {
			owner,
			repo: promptName,
			commit_hash: result.commit_hash,
			manifest: result.manifest,
			examples: result.examples
		};
	}
	/**
	* This method should not be used directly, use `import { pull } from "langchain/hub"` instead.
	* Using this method directly returns the JSON string of the prompt rather than a LangChain object.
	* @private
	*/
	async _pullPrompt(promptIdentifier, options) {
		const promptObject = await this.pullPromptCommit(promptIdentifier, { includeModel: options?.includeModel });
		const prompt = JSON.stringify(promptObject.manifest);
		return prompt;
	}
	async pushPrompt(promptIdentifier, options) {
		if (await this.promptExists(promptIdentifier)) {
			if (options && Object.keys(options).some((key) => key !== "object")) await this.updatePrompt(promptIdentifier, {
				description: options?.description,
				readme: options?.readme,
				tags: options?.tags,
				isPublic: options?.isPublic
			});
		} else await this.createPrompt(promptIdentifier, {
			description: options?.description,
			readme: options?.readme,
			tags: options?.tags,
			isPublic: options?.isPublic
		});
		if (!options?.object) return await this._getPromptUrl(promptIdentifier);
		const url = await this.createCommit(promptIdentifier, options?.object, { parentCommitHash: options?.parentCommitHash });
		return url;
	}
	/**
	* Clone a public dataset to your own langsmith tenant.
	* This operation is idempotent. If you already have a dataset with the given name,
	* this function will do nothing.
	
	* @param {string} tokenOrUrl The token of the public dataset to clone.
	* @param {Object} [options] Additional options for cloning the dataset.
	* @param {string} [options.sourceApiUrl] The URL of the langsmith server where the data is hosted. Defaults to the API URL of your current client.
	* @param {string} [options.datasetName] The name of the dataset to create in your tenant. Defaults to the name of the public dataset.
	* @returns {Promise<void>}
	*/
	async clonePublicDataset(tokenOrUrl, options = {}) {
		const { sourceApiUrl = this.apiUrl, datasetName } = options;
		const [parsedApiUrl, tokenUuid] = this.parseTokenOrUrl(tokenOrUrl, sourceApiUrl);
		const sourceClient = new Client({
			apiUrl: parsedApiUrl,
			apiKey: "placeholder"
		});
		const ds = await sourceClient.readSharedDataset(tokenUuid);
		const finalDatasetName = datasetName || ds.name;
		try {
			if (await this.hasDataset({ datasetId: finalDatasetName })) {
				console.log(`Dataset ${finalDatasetName} already exists in your tenant. Skipping.`);
				return;
			}
		} catch (_) {}
		const examples = await sourceClient.listSharedExamples(tokenUuid);
		const dataset = await this.createDataset(finalDatasetName, {
			description: ds.description,
			dataType: ds.data_type || "kv",
			inputsSchema: ds.inputs_schema_definition ?? void 0,
			outputsSchema: ds.outputs_schema_definition ?? void 0
		});
		try {
			await this.createExamples({
				inputs: examples.map((e) => e.inputs),
				outputs: examples.flatMap((e) => e.outputs ? [e.outputs] : []),
				datasetId: dataset.id
			});
		} catch (e) {
			console.error(`An error occurred while creating dataset ${finalDatasetName}. You should delete it manually.`);
			throw e;
		}
	}
	parseTokenOrUrl(urlOrToken, apiUrl, numParts = 2, kind = "dataset") {
		try {
			assertUuid(urlOrToken);
			return [apiUrl, urlOrToken];
		} catch (_) {}
		try {
			const parsedUrl = new URL(urlOrToken);
			const pathParts = parsedUrl.pathname.split("/").filter((part) => part !== "");
			if (pathParts.length >= numParts) {
				const tokenUuid = pathParts[pathParts.length - numParts];
				return [apiUrl, tokenUuid];
			} else throw new Error(`Invalid public ${kind} URL: ${urlOrToken}`);
		} catch (error) {
			throw new Error(`Invalid public ${kind} URL or token: ${urlOrToken}`);
		}
	}
	/**
	* Awaits all pending trace batches. Useful for environments where
	* you need to be sure that all tracing requests finish before execution ends,
	* such as serverless environments.
	*
	* @example
	* ```
	* import { Client } from "langsmith";
	*
	* const client = new Client();
	*
	* try {
	*   // Tracing happens here
	*   ...
	* } finally {
	*   await client.awaitPendingTraceBatches();
	* }
	* ```
	*
	* @returns A promise that resolves once all currently pending traces have sent.
	*/
	awaitPendingTraceBatches() {
		if (this.manualFlushMode) {
			console.warn("[WARNING]: When tracing in manual flush mode, you must call `await client.flush()` manually to submit trace batches.");
			return Promise.resolve();
		}
		return Promise.all([...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise), this.batchIngestCaller.queue.onIdle()]);
	}
};
function isExampleCreate(input) {
	return "dataset_id" in input || "dataset_name" in input;
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/env.js
const isTracingEnabled$1 = (tracingEnabled) => {
	if (tracingEnabled !== void 0) return tracingEnabled;
	const envVars = ["TRACING_V2", "TRACING"];
	return !!envVars.find((envVar) => getLangSmithEnvironmentVariable(envVar) === "true");
};

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/singletons/constants.js
const _LC_CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/run_trees.js
function stripNonAlphanumeric$1(input) {
	return input.replace(/[-:.]/g, "");
}
function convertToDottedOrderFormat$1(epoch, runId, executionOrder = 1) {
	const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
	return stripNonAlphanumeric$1(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId;
}
/**
* Baggage header information
*/
var Baggage = class Baggage {
	constructor(metadata, tags, project_name) {
		Object.defineProperty(this, "metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "tags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "project_name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.metadata = metadata;
		this.tags = tags;
		this.project_name = project_name;
	}
	static fromHeader(value) {
		const items = value.split(",");
		let metadata = {};
		let tags = [];
		let project_name;
		for (const item of items) {
			const [key, uriValue] = item.split("=");
			const value$1 = decodeURIComponent(uriValue);
			if (key === "langsmith-metadata") metadata = JSON.parse(value$1);
			else if (key === "langsmith-tags") tags = value$1.split(",");
			else if (key === "langsmith-project") project_name = value$1;
		}
		return new Baggage(metadata, tags, project_name);
	}
	toHeader() {
		const items = [];
		if (this.metadata && Object.keys(this.metadata).length > 0) items.push(`langsmith-metadata=${encodeURIComponent(JSON.stringify(this.metadata))}`);
		if (this.tags && this.tags.length > 0) items.push(`langsmith-tags=${encodeURIComponent(this.tags.join(","))}`);
		if (this.project_name) items.push(`langsmith-project=${encodeURIComponent(this.project_name)}`);
		return items.join(",");
	}
};
var RunTree = class RunTree {
	constructor(originalConfig) {
		Object.defineProperty(this, "id", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "run_type", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "project_name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "parent_run", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "child_runs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "start_time", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "end_time", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "extra", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "tags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "error", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "serialized", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "inputs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "outputs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "reference_example_id", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "client", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "events", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "trace_id", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "dotted_order", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "tracingEnabled", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "execution_order", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "child_execution_order", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/**
		* Attachments associated with the run.
		* Each entry is a tuple of [mime_type, bytes]
		*/
		Object.defineProperty(this, "attachments", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		if (isRunTree(originalConfig)) {
			Object.assign(this, { ...originalConfig });
			return;
		}
		const defaultConfig = RunTree.getDefaultConfig();
		const { metadata,...config } = originalConfig;
		const client$1 = config.client ?? RunTree.getSharedClient();
		const dedupedMetadata = {
			...metadata,
			...config?.extra?.metadata
		};
		config.extra = {
			...config.extra,
			metadata: dedupedMetadata
		};
		Object.assign(this, {
			...defaultConfig,
			...config,
			client: client$1
		});
		if (!this.trace_id) if (this.parent_run) this.trace_id = this.parent_run.trace_id ?? this.id;
		else this.trace_id = this.id;
		this.execution_order ??= 1;
		this.child_execution_order ??= 1;
		if (!this.dotted_order) {
			const currentDottedOrder = convertToDottedOrderFormat$1(this.start_time, this.id, this.execution_order);
			if (this.parent_run) this.dotted_order = this.parent_run.dotted_order + "." + currentDottedOrder;
			else this.dotted_order = currentDottedOrder;
		}
	}
	set metadata(metadata) {
		this.extra = {
			...this.extra,
			metadata: {
				...this.extra?.metadata,
				...metadata
			}
		};
	}
	get metadata() {
		return this.extra?.metadata;
	}
	static getDefaultConfig() {
		return {
			id: v4_default(),
			run_type: "chain",
			project_name: getLangSmithEnvironmentVariable("PROJECT") ?? getEnvironmentVariable$1("LANGCHAIN_SESSION") ?? "default",
			child_runs: [],
			api_url: getEnvironmentVariable$1("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
			api_key: getEnvironmentVariable$1("LANGCHAIN_API_KEY"),
			caller_options: {},
			start_time: Date.now(),
			serialized: {},
			inputs: {},
			extra: {}
		};
	}
	static getSharedClient() {
		if (!RunTree.sharedClient) RunTree.sharedClient = new Client();
		return RunTree.sharedClient;
	}
	createChild(config) {
		const child_execution_order = this.child_execution_order + 1;
		const child = new RunTree({
			...config,
			parent_run: this,
			project_name: this.project_name,
			client: this.client,
			tracingEnabled: this.tracingEnabled,
			execution_order: child_execution_order,
			child_execution_order
		});
		if (_LC_CONTEXT_VARIABLES_KEY in this) child[_LC_CONTEXT_VARIABLES_KEY] = this[_LC_CONTEXT_VARIABLES_KEY];
		const LC_CHILD = Symbol.for("lc:child_config");
		const presentConfig = config.extra?.[LC_CHILD] ?? this.extra[LC_CHILD];
		if (isRunnableConfigLike(presentConfig)) {
			const newConfig = { ...presentConfig };
			const callbacks = isCallbackManagerLike(newConfig.callbacks) ? newConfig.callbacks.copy?.() : void 0;
			if (callbacks) {
				Object.assign(callbacks, { _parentRunId: child.id });
				callbacks.handlers?.find(isLangChainTracerLike)?.updateFromRunTree?.(child);
				newConfig.callbacks = callbacks;
			}
			child.extra[LC_CHILD] = newConfig;
		}
		const visited = /* @__PURE__ */ new Set();
		let current = this;
		while (current != null && !visited.has(current.id)) {
			visited.add(current.id);
			current.child_execution_order = Math.max(current.child_execution_order, child_execution_order);
			current = current.parent_run;
		}
		this.child_runs.push(child);
		return child;
	}
	async end(outputs, error, endTime = Date.now(), metadata) {
		this.outputs = this.outputs ?? outputs;
		this.error = this.error ?? error;
		this.end_time = this.end_time ?? endTime;
		if (metadata && Object.keys(metadata).length > 0) this.extra = this.extra ? {
			...this.extra,
			metadata: {
				...this.extra.metadata,
				...metadata
			}
		} : { metadata };
	}
	_convertToCreate(run, runtimeEnv, excludeChildRuns = true) {
		const runExtra = run.extra ?? {};
		if (!runExtra.runtime) runExtra.runtime = {};
		if (runtimeEnv) {
			for (const [k, v] of Object.entries(runtimeEnv)) if (!runExtra.runtime[k]) runExtra.runtime[k] = v;
		}
		let child_runs;
		let parent_run_id;
		if (!excludeChildRuns) {
			child_runs = run.child_runs.map((child_run) => this._convertToCreate(child_run, runtimeEnv, excludeChildRuns));
			parent_run_id = void 0;
		} else {
			parent_run_id = run.parent_run?.id;
			child_runs = [];
		}
		const persistedRun = {
			id: run.id,
			name: run.name,
			start_time: run.start_time,
			end_time: run.end_time,
			run_type: run.run_type,
			reference_example_id: run.reference_example_id,
			extra: runExtra,
			serialized: run.serialized,
			error: run.error,
			inputs: run.inputs,
			outputs: run.outputs,
			session_name: run.project_name,
			child_runs,
			parent_run_id,
			trace_id: run.trace_id,
			dotted_order: run.dotted_order,
			tags: run.tags,
			attachments: run.attachments
		};
		return persistedRun;
	}
	async postRun(excludeChildRuns = true) {
		try {
			const runtimeEnv = getRuntimeEnvironment$1();
			const runCreate = await this._convertToCreate(this, runtimeEnv, true);
			await this.client.createRun(runCreate);
			if (!excludeChildRuns) {
				warnOnce("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
				for (const childRun of this.child_runs) await childRun.postRun(false);
			}
		} catch (error) {
			console.error(`Error in postRun for run ${this.id}:`, error);
		}
	}
	async patchRun() {
		try {
			const runUpdate = {
				end_time: this.end_time,
				error: this.error,
				inputs: this.inputs,
				outputs: this.outputs,
				parent_run_id: this.parent_run?.id,
				reference_example_id: this.reference_example_id,
				extra: this.extra,
				events: this.events,
				dotted_order: this.dotted_order,
				trace_id: this.trace_id,
				tags: this.tags,
				attachments: this.attachments,
				session_name: this.project_name
			};
			await this.client.updateRun(this.id, runUpdate);
		} catch (error) {
			console.error(`Error in patchRun for run ${this.id}`, error);
		}
	}
	toJSON() {
		return this._convertToCreate(this, void 0, false);
	}
	/**
	* Add an event to the run tree.
	* @param event - A single event or string to add
	*/
	addEvent(event) {
		if (!this.events) this.events = [];
		if (typeof event === "string") this.events.push({
			name: "event",
			time: (/* @__PURE__ */ new Date()).toISOString(),
			message: event
		});
		else this.events.push({
			...event,
			time: event.time ?? (/* @__PURE__ */ new Date()).toISOString()
		});
	}
	static fromRunnableConfig(parentConfig, props) {
		const callbackManager = parentConfig?.callbacks;
		let parentRun;
		let projectName;
		let client$1;
		let tracingEnabled = isTracingEnabled$1();
		if (callbackManager) {
			const parentRunId = callbackManager?.getParentRunId?.() ?? "";
			const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
			parentRun = langChainTracer?.getRun?.(parentRunId);
			projectName = langChainTracer?.projectName;
			client$1 = langChainTracer?.client;
			tracingEnabled = tracingEnabled || !!langChainTracer;
		}
		if (!parentRun) return new RunTree({
			...props,
			client: client$1,
			tracingEnabled,
			project_name: projectName
		});
		const parentRunTree = new RunTree({
			name: parentRun.name,
			id: parentRun.id,
			trace_id: parentRun.trace_id,
			dotted_order: parentRun.dotted_order,
			client: client$1,
			tracingEnabled,
			project_name: projectName,
			tags: [...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? []))],
			extra: { metadata: {
				...parentRun?.extra?.metadata,
				...parentConfig?.metadata
			} }
		});
		return parentRunTree.createChild(props);
	}
	static fromDottedOrder(dottedOrder) {
		return this.fromHeaders({ "langsmith-trace": dottedOrder });
	}
	static fromHeaders(headers, inheritArgs) {
		const rawHeaders = "get" in headers && typeof headers.get === "function" ? {
			"langsmith-trace": headers.get("langsmith-trace"),
			baggage: headers.get("baggage")
		} : headers;
		const headerTrace = rawHeaders["langsmith-trace"];
		if (!headerTrace || typeof headerTrace !== "string") return void 0;
		const parentDottedOrder = headerTrace.trim();
		const parsedDottedOrder = parentDottedOrder.split(".").map((part) => {
			const [strTime, uuid] = part.split("Z");
			return {
				strTime,
				time: Date.parse(strTime + "Z"),
				uuid
			};
		});
		const traceId = parsedDottedOrder[0].uuid;
		const config = {
			...inheritArgs,
			name: inheritArgs?.["name"] ?? "parent",
			run_type: inheritArgs?.["run_type"] ?? "chain",
			start_time: inheritArgs?.["start_time"] ?? Date.now(),
			id: parsedDottedOrder.at(-1)?.uuid,
			trace_id: traceId,
			dotted_order: parentDottedOrder
		};
		if (rawHeaders["baggage"] && typeof rawHeaders["baggage"] === "string") {
			const baggage = Baggage.fromHeader(rawHeaders["baggage"]);
			config.metadata = baggage.metadata;
			config.tags = baggage.tags;
			config.project_name = baggage.project_name;
		}
		return new RunTree(config);
	}
	toHeaders(headers) {
		const result = {
			"langsmith-trace": this.dotted_order,
			baggage: new Baggage(this.extra?.metadata, this.tags, this.project_name).toHeader()
		};
		if (headers) for (const [key, value] of Object.entries(result)) headers.set(key, value);
		return result;
	}
};
Object.defineProperty(RunTree, "sharedClient", {
	enumerable: true,
	configurable: true,
	writable: true,
	value: null
});
function isRunTree(x) {
	return x !== void 0 && typeof x.createChild === "function" && typeof x.postRun === "function";
}
function isLangChainTracerLike(x) {
	return typeof x === "object" && x != null && typeof x.name === "string" && x.name === "langchain_tracer";
}
function containsLangChainTracerLike(x) {
	return Array.isArray(x) && x.some((callback) => isLangChainTracerLike(callback));
}
function isCallbackManagerLike(x) {
	return typeof x === "object" && x != null && Array.isArray(x.handlers);
}
function isRunnableConfigLike(x) {
	return x !== void 0 && typeof x.callbacks === "object" && (containsLangChainTracerLike(x.callbacks?.handlers) || containsLangChainTracerLike(x.callbacks));
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/index.js
const __version__ = "0.3.30";

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/singletons/async_local_storage/globals.js
const TRACING_ALS_KEY$1 = Symbol.for("ls:tracing_async_local_storage");
const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
const setGlobalAsyncLocalStorageInstance = (instance) => {
	globalThis[TRACING_ALS_KEY$1] = instance;
};
const getGlobalAsyncLocalStorageInstance = () => {
	return globalThis[TRACING_ALS_KEY$1];
};

//#endregion
//#region node_modules/.pnpm/decamelize@1.2.0/node_modules/decamelize/index.js
var require_decamelize = __commonJS({ "node_modules/.pnpm/decamelize@1.2.0/node_modules/decamelize/index.js"(exports, module) {
	module.exports = function(str, sep) {
		if (typeof str !== "string") throw new TypeError("Expected a string");
		sep = typeof sep === "undefined" ? "_" : sep;
		return str.replace(/([a-z\d])([A-Z])/g, "$1" + sep + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + sep + "$2").toLowerCase();
	};
} });

//#endregion
//#region node_modules/.pnpm/camelcase@6.3.0/node_modules/camelcase/index.js
var require_camelcase = __commonJS({ "node_modules/.pnpm/camelcase@6.3.0/node_modules/camelcase/index.js"(exports, module) {
	const UPPERCASE = /[\p{Lu}]/u;
	const LOWERCASE = /[\p{Ll}]/u;
	const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
	const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
	const SEPARATORS = /[_.\- ]+/;
	const LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
	const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
	const NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
	const preserveCamelCase = (string, toLowerCase, toUpperCase) => {
		let isLastCharLower = false;
		let isLastCharUpper = false;
		let isLastLastCharUpper = false;
		for (let i = 0; i < string.length; i++) {
			const character = string[i];
			if (isLastCharLower && UPPERCASE.test(character)) {
				string = string.slice(0, i) + "-" + string.slice(i);
				isLastCharLower = false;
				isLastLastCharUpper = isLastCharUpper;
				isLastCharUpper = true;
				i++;
			} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character)) {
				string = string.slice(0, i - 1) + "-" + string.slice(i - 1);
				isLastLastCharUpper = isLastCharUpper;
				isLastCharUpper = false;
				isLastCharLower = true;
			} else {
				isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
				isLastLastCharUpper = isLastCharUpper;
				isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
			}
		}
		return string;
	};
	const preserveConsecutiveUppercase = (input, toLowerCase) => {
		LEADING_CAPITAL.lastIndex = 0;
		return input.replace(LEADING_CAPITAL, (m1) => toLowerCase(m1));
	};
	const postProcess = (input, toUpperCase) => {
		SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
		NUMBERS_AND_IDENTIFIER.lastIndex = 0;
		return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier)).replace(NUMBERS_AND_IDENTIFIER, (m) => toUpperCase(m));
	};
	const camelCase$1 = (input, options) => {
		if (!(typeof input === "string" || Array.isArray(input))) throw new TypeError("Expected the input to be `string | string[]`");
		options = {
			pascalCase: false,
			preserveConsecutiveUppercase: false,
			...options
		};
		if (Array.isArray(input)) input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
		else input = input.trim();
		if (input.length === 0) return "";
		const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
		const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
		if (input.length === 1) return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
		const hasUpperCase = input !== toLowerCase(input);
		if (hasUpperCase) input = preserveCamelCase(input, toLowerCase, toUpperCase);
		input = input.replace(LEADING_SEPARATORS, "");
		if (options.preserveConsecutiveUppercase) input = preserveConsecutiveUppercase(input, toLowerCase);
		else input = toLowerCase(input);
		if (options.pascalCase) input = toUpperCase(input.charAt(0)) + input.slice(1);
		return postProcess(input, toUpperCase);
	};
	module.exports = camelCase$1;
	module.exports.default = camelCase$1;
} });

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/load/map_keys.js
var import_decamelize = __toESM(require_decamelize(), 1);
var import_camelcase = __toESM(require_camelcase(), 1);
function keyToJson(key, map) {
	return map?.[key] || (0, import_decamelize.default)(key);
}
function keyFromJson(key, map) {
	return map?.[key] || (0, import_camelcase.default)(key);
}
function mapKeys(fields, mapper, map) {
	const mapped = {};
	for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
	return mapped;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/load/serializable.js
var serializable_exports = {};
__export(serializable_exports, {
	Serializable: () => Serializable,
	get_lc_unique_name: () => get_lc_unique_name
});
function shallowCopy(obj) {
	return Array.isArray(obj) ? [...obj] : { ...obj };
}
function replaceSecrets(root, secretsMap) {
	const result = shallowCopy(root);
	for (const [path, secretId] of Object.entries(secretsMap)) {
		const [last, ...partsReverse] = path.split(".").reverse();
		let current = result;
		for (const part of partsReverse.reverse()) {
			if (current[part] === void 0) break;
			current[part] = shallowCopy(current[part]);
			current = current[part];
		}
		if (current[last] !== void 0) current[last] = {
			lc: 1,
			type: "secret",
			id: [secretId]
		};
	}
	return result;
}
/**
* Get a unique name for the module, rather than parent class implementations.
* Should not be subclassed, subclass lc_name above instead.
*/
function get_lc_unique_name(serializableClass) {
	const parentClass = Object.getPrototypeOf(serializableClass);
	const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" && (typeof parentClass.lc_name !== "function" || serializableClass.lc_name() !== parentClass.lc_name());
	if (lcNameIsSubclassed) return serializableClass.lc_name();
	else return serializableClass.name;
}
var Serializable = class Serializable {
	/**
	* The name of the serializable. Override to provide an alias or
	* to preserve the serialized module name in minified environments.
	*
	* Implemented as a static method to support loading logic.
	*/
	static lc_name() {
		return this.name;
	}
	/**
	* The final serialized identifier for the module.
	*/
	get lc_id() {
		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
	}
	/**
	* A map of secrets, which will be omitted from serialization.
	* Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
	* Values are the secret ids, which will be used when deserializing.
	*/
	get lc_secrets() {
		return void 0;
	}
	/**
	* A map of additional attributes to merge with constructor args.
	* Keys are the attribute names, e.g. "foo".
	* Values are the attribute values, which will be serialized.
	* These attributes need to be accepted by the constructor as arguments.
	*/
	get lc_attributes() {
		return void 0;
	}
	/**
	* A map of aliases for constructor args.
	* Keys are the attribute names, e.g. "foo".
	* Values are the alias that will replace the key in serialization.
	* This is used to eg. make argument names match Python.
	*/
	get lc_aliases() {
		return void 0;
	}
	/**
	* A manual list of keys that should be serialized.
	* If not overridden, all fields passed into the constructor will be serialized.
	*/
	get lc_serializable_keys() {
		return void 0;
	}
	constructor(kwargs, ..._args) {
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "lc_kwargs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		if (this.lc_serializable_keys !== void 0) this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => this.lc_serializable_keys?.includes(key)));
		else this.lc_kwargs = kwargs ?? {};
	}
	toJSON() {
		if (!this.lc_serializable) return this.toJSONNotImplemented();
		if (this.lc_kwargs instanceof Serializable || typeof this.lc_kwargs !== "object" || Array.isArray(this.lc_kwargs)) return this.toJSONNotImplemented();
		const aliases = {};
		const secrets = {};
		const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
			acc[key] = key in this ? this[key] : this.lc_kwargs[key];
			return acc;
		}, {});
		for (let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
			Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
			Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
			Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
		}
		Object.keys(secrets).forEach((keyPath) => {
			let read = this;
			let write = kwargs;
			const [last, ...partsReverse] = keyPath.split(".").reverse();
			for (const key of partsReverse.reverse()) {
				if (!(key in read) || read[key] === void 0) return;
				if (!(key in write) || write[key] === void 0) {
					if (typeof read[key] === "object" && read[key] != null) write[key] = {};
					else if (Array.isArray(read[key])) write[key] = [];
				}
				read = read[key];
				write = write[key];
			}
			if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
		});
		return {
			lc: 1,
			type: "constructor",
			id: this.lc_id,
			kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases)
		};
	}
	toJSONNotImplemented() {
		return {
			lc: 1,
			type: "not_implemented",
			id: this.lc_id
		};
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/env.js
var env_exports = {};
__export(env_exports, {
	getEnv: () => getEnv,
	getEnvironmentVariable: () => getEnvironmentVariable,
	getRuntimeEnvironment: () => getRuntimeEnvironment,
	isBrowser: () => isBrowser,
	isDeno: () => isDeno,
	isJsDom: () => isJsDom,
	isNode: () => isNode,
	isWebWorker: () => isWebWorker
});
const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
const isWebWorker = () => typeof globalThis === "object" && globalThis.constructor && globalThis.constructor.name === "DedicatedWorkerGlobalScope";
const isJsDom = () => typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
const isDeno = () => typeof Deno !== "undefined";
const isNode = () => typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined" && !isDeno();
const getEnv = () => {
	let env;
	if (isBrowser()) env = "browser";
	else if (isNode()) env = "node";
	else if (isWebWorker()) env = "webworker";
	else if (isJsDom()) env = "jsdom";
	else if (isDeno()) env = "deno";
	else env = "other";
	return env;
};
let runtimeEnvironment;
async function getRuntimeEnvironment() {
	if (runtimeEnvironment === void 0) {
		const env = getEnv();
		runtimeEnvironment = {
			library: "langchain-js",
			runtime: env
		};
	}
	return runtimeEnvironment;
}
function getEnvironmentVariable(name) {
	try {
		if (typeof process !== "undefined") return process.env?.[name];
		else if (isDeno()) return Deno?.env.get(name);
		else return void 0;
	} catch (e) {
		return void 0;
	}
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/callbacks/base.js
var base_exports$1 = {};
__export(base_exports$1, {
	BaseCallbackHandler: () => BaseCallbackHandler,
	callbackHandlerPrefersStreaming: () => callbackHandlerPrefersStreaming,
	isBaseCallbackHandler: () => isBaseCallbackHandler
});
/**
* Abstract class that provides a set of optional methods that can be
* overridden in derived classes to handle various events during the
* execution of a LangChain application.
*/
var BaseCallbackHandlerMethodsClass = class {};
function callbackHandlerPrefersStreaming(x) {
	return "lc_prefer_streaming" in x && x.lc_prefer_streaming;
}
/**
* Abstract base class for creating callback handlers in the LangChain
* framework. It provides a set of optional methods that can be overridden
* in derived classes to handle various events during the execution of a
* LangChain application.
*/
var BaseCallbackHandler = class extends BaseCallbackHandlerMethodsClass {
	get lc_namespace() {
		return [
			"langchain_core",
			"callbacks",
			this.name
		];
	}
	get lc_secrets() {
		return void 0;
	}
	get lc_attributes() {
		return void 0;
	}
	get lc_aliases() {
		return void 0;
	}
	get lc_serializable_keys() {
		return void 0;
	}
	/**
	* The name of the serializable. Override to provide an alias or
	* to preserve the serialized module name in minified environments.
	*
	* Implemented as a static method to support loading logic.
	*/
	static lc_name() {
		return this.name;
	}
	/**
	* The final serialized identifier for the module.
	*/
	get lc_id() {
		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
	}
	constructor(input) {
		super();
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "lc_kwargs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "ignoreLLM", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "ignoreChain", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "ignoreAgent", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "ignoreRetriever", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "ignoreCustomEvent", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "raiseError", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "awaitHandlers", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
		});
		this.lc_kwargs = input || {};
		if (input) {
			this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM;
			this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
			this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
			this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
			this.ignoreCustomEvent = input.ignoreCustomEvent ?? this.ignoreCustomEvent;
			this.raiseError = input.raiseError ?? this.raiseError;
			this.awaitHandlers = this.raiseError || (input._awaitHandler ?? this.awaitHandlers);
		}
	}
	copy() {
		return new this.constructor(this);
	}
	toJSON() {
		return Serializable.prototype.toJSON.call(this);
	}
	toJSONNotImplemented() {
		return Serializable.prototype.toJSONNotImplemented.call(this);
	}
	static fromMethods(methods) {
		class Handler extends BaseCallbackHandler {
			constructor() {
				super();
				Object.defineProperty(this, "name", {
					enumerable: true,
					configurable: true,
					writable: true,
					value: v4_default()
				});
				Object.assign(this, methods);
			}
		}
		return new Handler();
	}
};
const isBaseCallbackHandler = (x) => {
	const callbackHandler = x;
	return callbackHandler !== void 0 && typeof callbackHandler.copy === "function" && typeof callbackHandler.name === "string" && typeof callbackHandler.awaitHandlers === "boolean";
};

//#endregion
//#region node_modules/.pnpm/ansi-styles@5.2.0/node_modules/ansi-styles/index.js
var require_ansi_styles = __commonJS({ "node_modules/.pnpm/ansi-styles@5.2.0/node_modules/ansi-styles/index.js"(exports, module) {
	const ANSI_BACKGROUND_OFFSET = 10;
	const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
	const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
	function assembleStyles() {
		const codes = /* @__PURE__ */ new Map();
		const styles$1 = {
			modifier: {
				reset: [0, 0],
				bold: [1, 22],
				dim: [2, 22],
				italic: [3, 23],
				underline: [4, 24],
				overline: [53, 55],
				inverse: [7, 27],
				hidden: [8, 28],
				strikethrough: [9, 29]
			},
			color: {
				black: [30, 39],
				red: [31, 39],
				green: [32, 39],
				yellow: [33, 39],
				blue: [34, 39],
				magenta: [35, 39],
				cyan: [36, 39],
				white: [37, 39],
				blackBright: [90, 39],
				redBright: [91, 39],
				greenBright: [92, 39],
				yellowBright: [93, 39],
				blueBright: [94, 39],
				magentaBright: [95, 39],
				cyanBright: [96, 39],
				whiteBright: [97, 39]
			},
			bgColor: {
				bgBlack: [40, 49],
				bgRed: [41, 49],
				bgGreen: [42, 49],
				bgYellow: [43, 49],
				bgBlue: [44, 49],
				bgMagenta: [45, 49],
				bgCyan: [46, 49],
				bgWhite: [47, 49],
				bgBlackBright: [100, 49],
				bgRedBright: [101, 49],
				bgGreenBright: [102, 49],
				bgYellowBright: [103, 49],
				bgBlueBright: [104, 49],
				bgMagentaBright: [105, 49],
				bgCyanBright: [106, 49],
				bgWhiteBright: [107, 49]
			}
		};
		styles$1.color.gray = styles$1.color.blackBright;
		styles$1.bgColor.bgGray = styles$1.bgColor.bgBlackBright;
		styles$1.color.grey = styles$1.color.blackBright;
		styles$1.bgColor.bgGrey = styles$1.bgColor.bgBlackBright;
		for (const [groupName, group] of Object.entries(styles$1)) {
			for (const [styleName, style] of Object.entries(group)) {
				styles$1[styleName] = {
					open: `\u001B[${style[0]}m`,
					close: `\u001B[${style[1]}m`
				};
				group[styleName] = styles$1[styleName];
				codes.set(style[0], style[1]);
			}
			Object.defineProperty(styles$1, groupName, {
				value: group,
				enumerable: false
			});
		}
		Object.defineProperty(styles$1, "codes", {
			value: codes,
			enumerable: false
		});
		styles$1.color.close = "\x1B[39m";
		styles$1.bgColor.close = "\x1B[49m";
		styles$1.color.ansi256 = wrapAnsi256();
		styles$1.color.ansi16m = wrapAnsi16m();
		styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
		styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
		Object.defineProperties(styles$1, {
			rgbToAnsi256: {
				value: (red, green, blue) => {
					if (red === green && green === blue) {
						if (red < 8) return 16;
						if (red > 248) return 231;
						return Math.round((red - 8) / 247 * 24) + 232;
					}
					return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
				},
				enumerable: false
			},
			hexToRgb: {
				value: (hex) => {
					const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
					if (!matches) return [
						0,
						0,
						0
					];
					let { colorString } = matches.groups;
					if (colorString.length === 3) colorString = colorString.split("").map((character) => character + character).join("");
					const integer = Number.parseInt(colorString, 16);
					return [
						integer >> 16 & 255,
						integer >> 8 & 255,
						integer & 255
					];
				},
				enumerable: false
			},
			hexToAnsi256: {
				value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
				enumerable: false
			}
		});
		return styles$1;
	}
	Object.defineProperty(module, "exports", {
		enumerable: true,
		get: assembleStyles
	});
} });

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tracers/base.js
var base_exports = {};
__export(base_exports, {
	BaseTracer: () => BaseTracer,
	isBaseTracer: () => isBaseTracer
});
function _coerceToDict$2(value, defaultKey) {
	return value && !Array.isArray(value) && typeof value === "object" ? value : { [defaultKey]: value };
}
function stripNonAlphanumeric(input) {
	return input.replace(/[-:.]/g, "");
}
function convertToDottedOrderFormat(epoch, runId, executionOrder) {
	const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
	return stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId;
}
function isBaseTracer(x) {
	return typeof x._addRunToRunMap === "function";
}
var BaseTracer = class extends BaseCallbackHandler {
	constructor(_fields) {
		super(...arguments);
		Object.defineProperty(this, "runMap", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: /* @__PURE__ */ new Map()
		});
	}
	copy() {
		return this;
	}
	stringifyError(error) {
		if (error instanceof Error) return error.message + (error?.stack ? `\n\n${error.stack}` : "");
		if (typeof error === "string") return error;
		return `${error}`;
	}
	_addChildRun(parentRun, childRun) {
		parentRun.child_runs.push(childRun);
	}
	_addRunToRunMap(run) {
		const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order);
		const storedRun = { ...run };
		if (storedRun.parent_run_id !== void 0) {
			const parentRun = this.runMap.get(storedRun.parent_run_id);
			if (parentRun) {
				this._addChildRun(parentRun, storedRun);
				parentRun.child_execution_order = Math.max(parentRun.child_execution_order, storedRun.child_execution_order);
				storedRun.trace_id = parentRun.trace_id;
				if (parentRun.dotted_order !== void 0) storedRun.dotted_order = [parentRun.dotted_order, currentDottedOrder].join(".");
			}
		} else {
			storedRun.trace_id = storedRun.id;
			storedRun.dotted_order = currentDottedOrder;
		}
		this.runMap.set(storedRun.id, storedRun);
		return storedRun;
	}
	async _endTrace(run) {
		const parentRun = run.parent_run_id !== void 0 && this.runMap.get(run.parent_run_id);
		if (parentRun) parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
		else await this.persistRun(run);
		this.runMap.delete(run.id);
		await this.onRunUpdate?.(run);
	}
	_getExecutionOrder(parentRunId) {
		const parentRun = parentRunId !== void 0 && this.runMap.get(parentRunId);
		if (!parentRun) return 1;
		return parentRun.child_execution_order + 1;
	}
	/**
	* Create and add a run to the run map for LLM start events.
	* This must sometimes be done synchronously to avoid race conditions
	* when callbacks are backgrounded, so we expose it as a separate method here.
	*/
	_createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
		const execution_order = this._getExecutionOrder(parentRunId);
		const start_time = Date.now();
		const finalExtraParams = metadata ? {
			...extraParams,
			metadata
		} : extraParams;
		const run = {
			id: runId,
			name: name ?? llm.id[llm.id.length - 1],
			parent_run_id: parentRunId,
			start_time,
			serialized: llm,
			events: [{
				name: "start",
				time: new Date(start_time).toISOString()
			}],
			inputs: { prompts },
			execution_order,
			child_runs: [],
			child_execution_order: execution_order,
			run_type: "llm",
			extra: finalExtraParams ?? {},
			tags: tags || []
		};
		return this._addRunToRunMap(run);
	}
	async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
		const run = this.runMap.get(runId) ?? this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
		await this.onRunCreate?.(run);
		await this.onLLMStart?.(run);
		return run;
	}
	/**
	* Create and add a run to the run map for chat model start events.
	* This must sometimes be done synchronously to avoid race conditions
	* when callbacks are backgrounded, so we expose it as a separate method here.
	*/
	_createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
		const execution_order = this._getExecutionOrder(parentRunId);
		const start_time = Date.now();
		const finalExtraParams = metadata ? {
			...extraParams,
			metadata
		} : extraParams;
		const run = {
			id: runId,
			name: name ?? llm.id[llm.id.length - 1],
			parent_run_id: parentRunId,
			start_time,
			serialized: llm,
			events: [{
				name: "start",
				time: new Date(start_time).toISOString()
			}],
			inputs: { messages },
			execution_order,
			child_runs: [],
			child_execution_order: execution_order,
			run_type: "llm",
			extra: finalExtraParams ?? {},
			tags: tags || []
		};
		return this._addRunToRunMap(run);
	}
	async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
		const run = this.runMap.get(runId) ?? this._createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name);
		await this.onRunCreate?.(run);
		await this.onLLMStart?.(run);
		return run;
	}
	async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "llm") throw new Error("No LLM run to end.");
		run.end_time = Date.now();
		run.outputs = output;
		run.events.push({
			name: "end",
			time: new Date(run.end_time).toISOString()
		});
		run.extra = {
			...run.extra,
			...extraParams
		};
		await this.onLLMEnd?.(run);
		await this._endTrace(run);
		return run;
	}
	async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "llm") throw new Error("No LLM run to end.");
		run.end_time = Date.now();
		run.error = this.stringifyError(error);
		run.events.push({
			name: "error",
			time: new Date(run.end_time).toISOString()
		});
		run.extra = {
			...run.extra,
			...extraParams
		};
		await this.onLLMError?.(run);
		await this._endTrace(run);
		return run;
	}
	/**
	* Create and add a run to the run map for chain start events.
	* This must sometimes be done synchronously to avoid race conditions
	* when callbacks are backgrounded, so we expose it as a separate method here.
	*/
	_createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
		const execution_order = this._getExecutionOrder(parentRunId);
		const start_time = Date.now();
		const run = {
			id: runId,
			name: name ?? chain.id[chain.id.length - 1],
			parent_run_id: parentRunId,
			start_time,
			serialized: chain,
			events: [{
				name: "start",
				time: new Date(start_time).toISOString()
			}],
			inputs,
			execution_order,
			child_execution_order: execution_order,
			run_type: runType ?? "chain",
			child_runs: [],
			extra: metadata ? { metadata } : {},
			tags: tags || []
		};
		return this._addRunToRunMap(run);
	}
	async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
		const run = this.runMap.get(runId) ?? this._createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
		await this.onRunCreate?.(run);
		await this.onChainStart?.(run);
		return run;
	}
	async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
		const run = this.runMap.get(runId);
		if (!run) throw new Error("No chain run to end.");
		run.end_time = Date.now();
		run.outputs = _coerceToDict$2(outputs, "output");
		run.events.push({
			name: "end",
			time: new Date(run.end_time).toISOString()
		});
		if (kwargs?.inputs !== void 0) run.inputs = _coerceToDict$2(kwargs.inputs, "input");
		await this.onChainEnd?.(run);
		await this._endTrace(run);
		return run;
	}
	async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
		const run = this.runMap.get(runId);
		if (!run) throw new Error("No chain run to end.");
		run.end_time = Date.now();
		run.error = this.stringifyError(error);
		run.events.push({
			name: "error",
			time: new Date(run.end_time).toISOString()
		});
		if (kwargs?.inputs !== void 0) run.inputs = _coerceToDict$2(kwargs.inputs, "input");
		await this.onChainError?.(run);
		await this._endTrace(run);
		return run;
	}
	/**
	* Create and add a run to the run map for tool start events.
	* This must sometimes be done synchronously to avoid race conditions
	* when callbacks are backgrounded, so we expose it as a separate method here.
	*/
	_createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
		const execution_order = this._getExecutionOrder(parentRunId);
		const start_time = Date.now();
		const run = {
			id: runId,
			name: name ?? tool.id[tool.id.length - 1],
			parent_run_id: parentRunId,
			start_time,
			serialized: tool,
			events: [{
				name: "start",
				time: new Date(start_time).toISOString()
			}],
			inputs: { input },
			execution_order,
			child_execution_order: execution_order,
			run_type: "tool",
			child_runs: [],
			extra: metadata ? { metadata } : {},
			tags: tags || []
		};
		return this._addRunToRunMap(run);
	}
	async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
		const run = this.runMap.get(runId) ?? this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
		await this.onRunCreate?.(run);
		await this.onToolStart?.(run);
		return run;
	}
	async handleToolEnd(output, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "tool") throw new Error("No tool run to end");
		run.end_time = Date.now();
		run.outputs = { output };
		run.events.push({
			name: "end",
			time: new Date(run.end_time).toISOString()
		});
		await this.onToolEnd?.(run);
		await this._endTrace(run);
		return run;
	}
	async handleToolError(error, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "tool") throw new Error("No tool run to end");
		run.end_time = Date.now();
		run.error = this.stringifyError(error);
		run.events.push({
			name: "error",
			time: new Date(run.end_time).toISOString()
		});
		await this.onToolError?.(run);
		await this._endTrace(run);
		return run;
	}
	async handleAgentAction(action, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "chain") return;
		const agentRun = run;
		agentRun.actions = agentRun.actions || [];
		agentRun.actions.push(action);
		agentRun.events.push({
			name: "agent_action",
			time: (/* @__PURE__ */ new Date()).toISOString(),
			kwargs: { action }
		});
		await this.onAgentAction?.(run);
	}
	async handleAgentEnd(action, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "chain") return;
		run.events.push({
			name: "agent_end",
			time: (/* @__PURE__ */ new Date()).toISOString(),
			kwargs: { action }
		});
		await this.onAgentEnd?.(run);
	}
	/**
	* Create and add a run to the run map for retriever start events.
	* This must sometimes be done synchronously to avoid race conditions
	* when callbacks are backgrounded, so we expose it as a separate method here.
	*/
	_createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
		const execution_order = this._getExecutionOrder(parentRunId);
		const start_time = Date.now();
		const run = {
			id: runId,
			name: name ?? retriever.id[retriever.id.length - 1],
			parent_run_id: parentRunId,
			start_time,
			serialized: retriever,
			events: [{
				name: "start",
				time: new Date(start_time).toISOString()
			}],
			inputs: { query },
			execution_order,
			child_execution_order: execution_order,
			run_type: "retriever",
			child_runs: [],
			extra: metadata ? { metadata } : {},
			tags: tags || []
		};
		return this._addRunToRunMap(run);
	}
	async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
		const run = this.runMap.get(runId) ?? this._createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name);
		await this.onRunCreate?.(run);
		await this.onRetrieverStart?.(run);
		return run;
	}
	async handleRetrieverEnd(documents, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "retriever") throw new Error("No retriever run to end");
		run.end_time = Date.now();
		run.outputs = { documents };
		run.events.push({
			name: "end",
			time: new Date(run.end_time).toISOString()
		});
		await this.onRetrieverEnd?.(run);
		await this._endTrace(run);
		return run;
	}
	async handleRetrieverError(error, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "retriever") throw new Error("No retriever run to end");
		run.end_time = Date.now();
		run.error = this.stringifyError(error);
		run.events.push({
			name: "error",
			time: new Date(run.end_time).toISOString()
		});
		await this.onRetrieverError?.(run);
		await this._endTrace(run);
		return run;
	}
	async handleText(text, runId) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "chain") return;
		run.events.push({
			name: "text",
			time: (/* @__PURE__ */ new Date()).toISOString(),
			kwargs: { text }
		});
		await this.onText?.(run);
	}
	async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
		const run = this.runMap.get(runId);
		if (!run || run?.run_type !== "llm") throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
		run.events.push({
			name: "new_token",
			time: (/* @__PURE__ */ new Date()).toISOString(),
			kwargs: {
				token,
				idx,
				chunk: fields?.chunk
			}
		});
		await this.onLLMNewToken?.(run, token, { chunk: fields?.chunk });
		return run;
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tracers/console.js
var console_exports = {};
__export(console_exports, { ConsoleCallbackHandler: () => ConsoleCallbackHandler });
var import_ansi_styles = __toESM(require_ansi_styles(), 1);
function wrap(style, text) {
	return `${style.open}${text}${style.close}`;
}
function tryJsonStringify(obj, fallback) {
	try {
		return JSON.stringify(obj, null, 2);
	} catch (err) {
		return fallback;
	}
}
function formatKVMapItem(value) {
	if (typeof value === "string") return value.trim();
	if (value === null || value === void 0) return value;
	return tryJsonStringify(value, value.toString());
}
function elapsed(run) {
	if (!run.end_time) return "";
	const elapsed$1 = run.end_time - run.start_time;
	if (elapsed$1 < 1e3) return `${elapsed$1}ms`;
	return `${(elapsed$1 / 1e3).toFixed(2)}s`;
}
const { color } = import_ansi_styles.default;
/**
* A tracer that logs all events to the console. It extends from the
* `BaseTracer` class and overrides its methods to provide custom logging
* functionality.
* @example
* ```typescript
*
* const llm = new ChatAnthropic({
*   temperature: 0,
*   tags: ["example", "callbacks", "constructor"],
*   callbacks: [new ConsoleCallbackHandler()],
* });
*
* ```
*/
var ConsoleCallbackHandler = class extends BaseTracer {
	constructor() {
		super(...arguments);
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "console_callback_handler"
		});
	}
	/**
	* Method used to persist the run. In this case, it simply returns a
	* resolved promise as there's no persistence logic.
	* @param _run The run to persist.
	* @returns A resolved promise.
	*/
	persistRun(_run) {
		return Promise.resolve();
	}
	/**
	* Method used to get all the parent runs of a given run.
	* @param run The run whose parents are to be retrieved.
	* @returns An array of parent runs.
	*/
	getParents(run) {
		const parents = [];
		let currentRun = run;
		while (currentRun.parent_run_id) {
			const parent = this.runMap.get(currentRun.parent_run_id);
			if (parent) {
				parents.push(parent);
				currentRun = parent;
			} else break;
		}
		return parents;
	}
	/**
	* Method used to get a string representation of the run's lineage, which
	* is used in logging.
	* @param run The run whose lineage is to be retrieved.
	* @returns A string representation of the run's lineage.
	*/
	getBreadcrumbs(run) {
		const parents = this.getParents(run).reverse();
		const string = [...parents, run].map((parent, i, arr$1) => {
			const name = `${parent.execution_order}:${parent.run_type}:${parent.name}`;
			return i === arr$1.length - 1 ? wrap(import_ansi_styles.default.bold, name) : name;
		}).join(" > ");
		return wrap(color.grey, string);
	}
	/**
	* Method used to log the start of a chain run.
	* @param run The chain run that has started.
	* @returns void
	*/
	onChainStart(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.green, "[chain/start]")} [${crumbs}] Entering Chain run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
	}
	/**
	* Method used to log the end of a chain run.
	* @param run The chain run that has ended.
	* @returns void
	*/
	onChainEnd(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.cyan, "[chain/end]")} [${crumbs}] [${elapsed(run)}] Exiting Chain run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
	}
	/**
	* Method used to log any errors of a chain run.
	* @param run The chain run that has errored.
	* @returns void
	*/
	onChainError(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.red, "[chain/error]")} [${crumbs}] [${elapsed(run)}] Chain run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
	}
	/**
	* Method used to log the start of an LLM run.
	* @param run The LLM run that has started.
	* @returns void
	*/
	onLLMStart(run) {
		const crumbs = this.getBreadcrumbs(run);
		const inputs = "prompts" in run.inputs ? { prompts: run.inputs.prompts.map((p) => p.trim()) } : run.inputs;
		console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify(inputs, "[inputs]")}`);
	}
	/**
	* Method used to log the end of an LLM run.
	* @param run The LLM run that has ended.
	* @returns void
	*/
	onLLMEnd(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.outputs, "[response]")}`);
	}
	/**
	* Method used to log any errors of an LLM run.
	* @param run The LLM run that has errored.
	* @returns void
	*/
	onLLMError(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.red, "[llm/error]")} [${crumbs}] [${elapsed(run)}] LLM run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
	}
	/**
	* Method used to log the start of a tool run.
	* @param run The tool run that has started.
	* @returns void
	*/
	onToolStart(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${formatKVMapItem(run.inputs.input)}"`);
	}
	/**
	* Method used to log the end of a tool run.
	* @param run The tool run that has ended.
	* @returns void
	*/
	onToolEnd(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${formatKVMapItem(run.outputs?.output)}"`);
	}
	/**
	* Method used to log any errors of a tool run.
	* @param run The tool run that has errored.
	* @returns void
	*/
	onToolError(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.red, "[tool/error]")} [${crumbs}] [${elapsed(run)}] Tool run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
	}
	/**
	* Method used to log the start of a retriever run.
	* @param run The retriever run that has started.
	* @returns void
	*/
	onRetrieverStart(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.green, "[retriever/start]")} [${crumbs}] Entering Retriever run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
	}
	/**
	* Method used to log the end of a retriever run.
	* @param run The retriever run that has ended.
	* @returns void
	*/
	onRetrieverEnd(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.cyan, "[retriever/end]")} [${crumbs}] [${elapsed(run)}] Exiting Retriever run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
	}
	/**
	* Method used to log any errors of a retriever run.
	* @param run The retriever run that has errored.
	* @returns void
	*/
	onRetrieverError(run) {
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.red, "[retriever/error]")} [${crumbs}] [${elapsed(run)}] Retriever run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
	}
	/**
	* Method used to log the action selected by the agent.
	* @param run The run in which the agent action occurred.
	* @returns void
	*/
	onAgentAction(run) {
		const agentRun = run;
		const crumbs = this.getBreadcrumbs(run);
		console.log(`${wrap(color.blue, "[agent/action]")} [${crumbs}] Agent selected action: ${tryJsonStringify(agentRun.actions[agentRun.actions.length - 1], "[action]")}`);
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/errors/index.js
function addLangChainErrorFields(error, lc_error_code) {
	error.lc_error_code = lc_error_code;
	error.message = `${error.message}\n\nTroubleshooting URL: https://js.langchain.com/docs/troubleshooting/errors/${lc_error_code}/\n`;
	return error;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tools/utils.js
function _isToolCall(toolCall) {
	return !!(toolCall && typeof toolCall === "object" && "type" in toolCall && toolCall.type === "tool_call");
}
function _configHasToolCallId(config) {
	return !!(config && typeof config === "object" && "toolCall" in config && config.toolCall != null && typeof config.toolCall === "object" && "id" in config.toolCall && typeof config.toolCall.id === "string");
}
/**
* Custom error class used to handle exceptions related to tool input parsing.
* It extends the built-in `Error` class and adds an optional `output`
* property that can hold the output that caused the exception.
*/
var ToolInputParsingException = class extends Error {
	constructor(message, output) {
		super(message);
		Object.defineProperty(this, "output", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.output = output;
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/json.js
function parseJsonMarkdown(s, parser = parsePartialJson) {
	s = s.trim();
	const firstFenceIndex = s.indexOf("```");
	if (firstFenceIndex === -1) return parser(s);
	let contentAfterFence = s.substring(firstFenceIndex + 3);
	if (contentAfterFence.startsWith("json\n")) contentAfterFence = contentAfterFence.substring(5);
	else if (contentAfterFence.startsWith("json")) contentAfterFence = contentAfterFence.substring(4);
	else if (contentAfterFence.startsWith("\n")) contentAfterFence = contentAfterFence.substring(1);
	const closingFenceIndex = contentAfterFence.indexOf("```");
	let finalContent = contentAfterFence;
	if (closingFenceIndex !== -1) finalContent = contentAfterFence.substring(0, closingFenceIndex);
	return parser(finalContent.trim());
}
function parsePartialJson(s) {
	if (typeof s === "undefined") return null;
	try {
		return JSON.parse(s);
	} catch (error) {}
	let new_s = "";
	const stack = [];
	let isInsideString = false;
	let escaped = false;
	for (let char of s) {
		if (isInsideString) if (char === "\"" && !escaped) isInsideString = false;
		else if (char === "\n" && !escaped) char = "\\n";
		else if (char === "\\") escaped = !escaped;
		else escaped = false;
		else if (char === "\"") {
			isInsideString = true;
			escaped = false;
		} else if (char === "{") stack.push("}");
		else if (char === "[") stack.push("]");
		else if (char === "}" || char === "]") if (stack && stack[stack.length - 1] === char) stack.pop();
		else return null;
		new_s += char;
	}
	if (isInsideString) new_s += "\"";
	for (let i = stack.length - 1; i >= 0; i -= 1) new_s += stack[i];
	try {
		return JSON.parse(new_s);
	} catch (error) {
		return null;
	}
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/content_blocks.js
function isDataContentBlock(content_block) {
	return typeof content_block === "object" && content_block !== null && "type" in content_block && typeof content_block.type === "string" && "source_type" in content_block && (content_block.source_type === "url" || content_block.source_type === "base64" || content_block.source_type === "text" || content_block.source_type === "id");
}
function isURLContentBlock(content_block) {
	return isDataContentBlock(content_block) && content_block.source_type === "url" && "url" in content_block && typeof content_block.url === "string";
}
function isBase64ContentBlock(content_block) {
	return isDataContentBlock(content_block) && content_block.source_type === "base64" && "data" in content_block && typeof content_block.data === "string";
}
function isPlainTextContentBlock(content_block) {
	return isDataContentBlock(content_block) && content_block.source_type === "text" && "text" in content_block && typeof content_block.text === "string";
}
function isIDContentBlock(content_block) {
	return isDataContentBlock(content_block) && content_block.source_type === "id" && "id" in content_block && typeof content_block.id === "string";
}
function convertToOpenAIImageBlock(content_block) {
	if (isDataContentBlock(content_block)) {
		if (content_block.source_type === "url") return {
			type: "image_url",
			image_url: { url: content_block.url }
		};
		if (content_block.source_type === "base64") {
			if (!content_block.mime_type) throw new Error("mime_type key is required for base64 data.");
			const mime_type = content_block.mime_type;
			return {
				type: "image_url",
				image_url: { url: `data:${mime_type};base64,${content_block.data}` }
			};
		}
	}
	throw new Error("Unsupported source type. Only 'url' and 'base64' are supported.");
}
/**
* Utility function for ChatModelProviders. Parses a mime type into a type, subtype, and parameters.
*
* @param mime_type - The mime type to parse.
* @returns An object containing the type, subtype, and parameters.
*/
function parseMimeType(mime_type) {
	const parts = mime_type.split(";")[0].split("/");
	if (parts.length !== 2) throw new Error(`Invalid mime type: "${mime_type}" - does not match type/subtype format.`);
	const type = parts[0].trim();
	const subtype = parts[1].trim();
	if (type === "" || subtype === "") throw new Error(`Invalid mime type: "${mime_type}" - type or subtype is empty.`);
	const parameters = {};
	for (const parameterKvp of mime_type.split(";").slice(1)) {
		const parameterParts = parameterKvp.split("=");
		if (parameterParts.length !== 2) throw new Error(`Invalid parameter syntax in mime type: "${mime_type}".`);
		const key = parameterParts[0].trim();
		const value = parameterParts[1].trim();
		if (key === "") throw new Error(`Invalid parameter syntax in mime type: "${mime_type}".`);
		parameters[key] = value;
	}
	return {
		type,
		subtype,
		parameters
	};
}
/**
* Utility function for ChatModelProviders. Parses a base64 data URL into a typed array or string.
*
* @param dataUrl - The base64 data URL to parse.
* @param asTypedArray - Whether to return the data as a typed array.
* @returns The parsed data and mime type, or undefined if the data URL is invalid.
*/
function parseBase64DataUrl({ dataUrl: data_url, asTypedArray = false }) {
	const formatMatch = data_url.match(/^data:(\w+\/\w+);base64,([A-Za-z0-9+/]+=*)$/);
	let mime_type;
	if (formatMatch) {
		mime_type = formatMatch[1].toLowerCase();
		const data = asTypedArray ? Uint8Array.from(atob(formatMatch[2]), (c) => c.charCodeAt(0)) : formatMatch[2];
		return {
			mime_type,
			data
		};
	}
	return void 0;
}
/**
* Convert from a standard data content block to a provider's proprietary data content block format.
*
* Don't override this method. Instead, override the more specific conversion methods and use this
* method unmodified.
*
* @param block - The standard data content block to convert.
* @returns The provider data content block.
* @throws An error if the standard data content block type is not supported.
*/
function convertToProviderContentBlock(block, converter) {
	if (block.type === "text") {
		if (!converter.fromStandardTextBlock) throw new Error(`Converter for ${converter.providerName} does not implement \`fromStandardTextBlock\` method.`);
		return converter.fromStandardTextBlock(block);
	}
	if (block.type === "image") {
		if (!converter.fromStandardImageBlock) throw new Error(`Converter for ${converter.providerName} does not implement \`fromStandardImageBlock\` method.`);
		return converter.fromStandardImageBlock(block);
	}
	if (block.type === "audio") {
		if (!converter.fromStandardAudioBlock) throw new Error(`Converter for ${converter.providerName} does not implement \`fromStandardAudioBlock\` method.`);
		return converter.fromStandardAudioBlock(block);
	}
	if (block.type === "file") {
		if (!converter.fromStandardFileBlock) throw new Error(`Converter for ${converter.providerName} does not implement \`fromStandardFileBlock\` method.`);
		return converter.fromStandardFileBlock(block);
	}
	throw new Error(`Unable to convert content block type '${block.type}' to provider-specific format: not recognized.`);
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/base.js
function mergeContent(firstContent, secondContent) {
	if (typeof firstContent === "string") {
		if (firstContent === "") return secondContent;
		if (typeof secondContent === "string") return firstContent + secondContent;
		else if (Array.isArray(secondContent) && secondContent.some((c) => isDataContentBlock(c))) return [{
			type: "text",
			source_type: "text",
			text: firstContent
		}, ...secondContent];
		else return [{
			type: "text",
			text: firstContent
		}, ...secondContent];
	} else if (Array.isArray(secondContent)) return _mergeLists(firstContent, secondContent) ?? [...firstContent, ...secondContent];
	else if (secondContent === "") return firstContent;
	else if (Array.isArray(firstContent) && firstContent.some((c) => isDataContentBlock(c))) return [...firstContent, {
		type: "file",
		source_type: "text",
		text: secondContent
	}];
	else return [...firstContent, {
		type: "text",
		text: secondContent
	}];
}
/**
* 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else
* it will return 'success'.
*
* @param {"success" | "error" | undefined} left The existing value to 'merge' with the new value.
* @param {"success" | "error" | undefined} right The new value to 'merge' with the existing value
* @returns {"success" | "error"} The 'merged' value.
*/
function _mergeStatus(left, right) {
	if (left === "error" || right === "error") return "error";
	return "success";
}
function stringifyWithDepthLimit(obj, depthLimit) {
	function helper(obj$1, currentDepth) {
		if (typeof obj$1 !== "object" || obj$1 === null || obj$1 === void 0) return obj$1;
		if (currentDepth >= depthLimit) {
			if (Array.isArray(obj$1)) return "[Array]";
			return "[Object]";
		}
		if (Array.isArray(obj$1)) return obj$1.map((item) => helper(item, currentDepth + 1));
		const result = {};
		for (const key of Object.keys(obj$1)) result[key] = helper(obj$1[key], currentDepth + 1);
		return result;
	}
	return JSON.stringify(helper(obj, 0), null, 2);
}
/**
* Base class for all types of messages in a conversation. It includes
* properties like `content`, `name`, and `additional_kwargs`. It also
* includes methods like `toDict()` and `_getType()`.
*/
var BaseMessage = class extends Serializable {
	get lc_aliases() {
		return {
			additional_kwargs: "additional_kwargs",
			response_metadata: "response_metadata"
		};
	}
	/**
	* Get text content of the message.
	*/
	get text() {
		if (typeof this.content === "string") return this.content;
		if (!Array.isArray(this.content)) return "";
		return this.content.map((c) => {
			if (typeof c === "string") return c;
			if (c.type === "text") return c.text;
			return "";
		}).join("");
	}
	/** The type of the message. */
	getType() {
		return this._getType();
	}
	constructor(fields, kwargs) {
		if (typeof fields === "string") fields = {
			content: fields,
			additional_kwargs: kwargs,
			response_metadata: {}
		};
		if (!fields.additional_kwargs) fields.additional_kwargs = {};
		if (!fields.response_metadata) fields.response_metadata = {};
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "messages"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		/** The content of the message. */
		Object.defineProperty(this, "content", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/** The name of the message sender in a multi-user chat. */
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/** Additional keyword arguments */
		Object.defineProperty(this, "additional_kwargs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/** Response metadata. For example: response headers, logprobs, token counts. */
		Object.defineProperty(this, "response_metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/**
		* An optional unique identifier for the message. This should ideally be
		* provided by the provider/model which created the message.
		*/
		Object.defineProperty(this, "id", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.name = fields.name;
		this.content = fields.content;
		this.additional_kwargs = fields.additional_kwargs;
		this.response_metadata = fields.response_metadata;
		this.id = fields.id;
	}
	toDict() {
		return {
			type: this._getType(),
			data: this.toJSON().kwargs
		};
	}
	static lc_name() {
		return "BaseMessage";
	}
	get _printableFields() {
		return {
			id: this.id,
			content: this.content,
			name: this.name,
			additional_kwargs: this.additional_kwargs,
			response_metadata: this.response_metadata
		};
	}
	_updateId(value) {
		this.id = value;
		this.lc_kwargs.id = value;
	}
	get [Symbol.toStringTag]() {
		return this.constructor.lc_name();
	}
	[Symbol.for("nodejs.util.inspect.custom")](depth) {
		if (depth === null) return this;
		const printable = stringifyWithDepthLimit(this._printableFields, Math.max(4, depth));
		return `${this.constructor.lc_name()} ${printable}`;
	}
};
function isOpenAIToolCallArray(value) {
	return Array.isArray(value) && value.every((v) => typeof v.index === "number");
}
function _mergeDicts(left, right) {
	const merged = { ...left };
	for (const [key, value] of Object.entries(right)) if (merged[key] == null) merged[key] = value;
	else if (value == null) continue;
	else if (typeof merged[key] !== typeof value || Array.isArray(merged[key]) !== Array.isArray(value)) throw new Error(`field[${key}] already exists in the message chunk, but with a different type.`);
	else if (typeof merged[key] === "string") {
		if (key === "type") continue;
		merged[key] += value;
	} else if (typeof merged[key] === "object" && !Array.isArray(merged[key])) merged[key] = _mergeDicts(merged[key], value);
	else if (Array.isArray(merged[key])) merged[key] = _mergeLists(merged[key], value);
	else if (merged[key] === value) continue;
	else console.warn(`field[${key}] already exists in this message chunk and value has unsupported type.`);
	return merged;
}
function _mergeLists(left, right) {
	if (left === void 0 && right === void 0) return void 0;
	else if (left === void 0 || right === void 0) return left || right;
	else {
		const merged = [...left];
		for (const item of right) if (typeof item === "object" && "index" in item && typeof item.index === "number") {
			const toMerge = merged.findIndex((leftItem) => leftItem.index === item.index);
			if (toMerge !== -1) merged[toMerge] = _mergeDicts(merged[toMerge], item);
			else merged.push(item);
		} else if (typeof item === "object" && "text" in item && item.text === "") continue;
		else merged.push(item);
		return merged;
	}
}
function _mergeObj(left, right) {
	if (!left && !right) throw new Error("Cannot merge two undefined objects.");
	if (!left || !right) return left || right;
	else if (typeof left !== typeof right) throw new Error(`Cannot merge objects of different types.\nLeft ${typeof left}\nRight ${typeof right}`);
	else if (typeof left === "string" && typeof right === "string") return left + right;
	else if (Array.isArray(left) && Array.isArray(right)) return _mergeLists(left, right);
	else if (typeof left === "object" && typeof right === "object") return _mergeDicts(left, right);
	else if (left === right) return left;
	else throw new Error(`Can not merge objects of different types.\nLeft ${left}\nRight ${right}`);
}
/**
* Represents a chunk of a message, which can be concatenated with other
* message chunks. It includes a method `_merge_kwargs_dict()` for merging
* additional keyword arguments from another `BaseMessageChunk` into this
* one. It also overrides the `__add__()` method to support concatenation
* of `BaseMessageChunk` instances.
*/
var BaseMessageChunk = class extends BaseMessage {};
function _isMessageFieldWithRole(x) {
	return typeof x.role === "string";
}
function isBaseMessage(messageLike) {
	return typeof messageLike?._getType === "function";
}
function isBaseMessageChunk(messageLike) {
	return isBaseMessage(messageLike) && typeof messageLike.concat === "function";
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/tool.js
function isDirectToolOutput(x) {
	return x != null && typeof x === "object" && "lc_direct_tool_output" in x && x.lc_direct_tool_output === true;
}
/**
* Represents a tool message in a conversation.
*/
var ToolMessage = class extends BaseMessage {
	static lc_name() {
		return "ToolMessage";
	}
	get lc_aliases() {
		return { tool_call_id: "tool_call_id" };
	}
	constructor(fields, tool_call_id, name) {
		if (typeof fields === "string") fields = {
			content: fields,
			name,
			tool_call_id
		};
		super(fields);
		Object.defineProperty(this, "lc_direct_tool_output", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		/**
		* Status of the tool invocation.
		* @version 0.2.19
		*/
		Object.defineProperty(this, "status", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "tool_call_id", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/**
		* Artifact of the Tool execution which is not meant to be sent to the model.
		*
		* Should only be specified if it is different from the message content, e.g. if only
		* a subset of the full tool output is being passed as message content but the full
		* output is needed in other parts of the code.
		*/
		Object.defineProperty(this, "artifact", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.tool_call_id = fields.tool_call_id;
		this.artifact = fields.artifact;
		this.status = fields.status;
	}
	_getType() {
		return "tool";
	}
	static isInstance(message) {
		return message._getType() === "tool";
	}
	get _printableFields() {
		return {
			...super._printableFields,
			tool_call_id: this.tool_call_id,
			artifact: this.artifact
		};
	}
};
/**
* Represents a chunk of a tool message, which can be concatenated
* with other tool message chunks.
*/
var ToolMessageChunk = class ToolMessageChunk extends BaseMessageChunk {
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "tool_call_id", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/**
		* Status of the tool invocation.
		* @version 0.2.19
		*/
		Object.defineProperty(this, "status", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/**
		* Artifact of the Tool execution which is not meant to be sent to the model.
		*
		* Should only be specified if it is different from the message content, e.g. if only
		* a subset of the full tool output is being passed as message content but the full
		* output is needed in other parts of the code.
		*/
		Object.defineProperty(this, "artifact", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.tool_call_id = fields.tool_call_id;
		this.artifact = fields.artifact;
		this.status = fields.status;
	}
	static lc_name() {
		return "ToolMessageChunk";
	}
	_getType() {
		return "tool";
	}
	concat(chunk) {
		return new ToolMessageChunk({
			content: mergeContent(this.content, chunk.content),
			additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
			response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
			artifact: _mergeObj(this.artifact, chunk.artifact),
			tool_call_id: this.tool_call_id,
			id: this.id ?? chunk.id,
			status: _mergeStatus(this.status, chunk.status)
		});
	}
	get _printableFields() {
		return {
			...super._printableFields,
			tool_call_id: this.tool_call_id,
			artifact: this.artifact
		};
	}
};
function defaultToolCallParser(rawToolCalls) {
	const toolCalls = [];
	const invalidToolCalls = [];
	for (const toolCall of rawToolCalls) if (!toolCall.function) continue;
	else {
		const functionName = toolCall.function.name;
		try {
			const functionArgs = JSON.parse(toolCall.function.arguments);
			const parsed = {
				name: functionName || "",
				args: functionArgs || {},
				id: toolCall.id
			};
			toolCalls.push(parsed);
		} catch (error) {
			invalidToolCalls.push({
				name: functionName,
				args: toolCall.function.arguments,
				id: toolCall.id,
				error: "Malformed args."
			});
		}
	}
	return [toolCalls, invalidToolCalls];
}
function isToolMessage(x) {
	return x._getType() === "tool";
}
function isToolMessageChunk(x) {
	return x._getType() === "tool";
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/ai.js
/**
* Represents an AI message in a conversation.
*/
var AIMessage = class extends BaseMessage {
	get lc_aliases() {
		return {
			...super.lc_aliases,
			tool_calls: "tool_calls",
			invalid_tool_calls: "invalid_tool_calls"
		};
	}
	constructor(fields, kwargs) {
		let initParams;
		if (typeof fields === "string") initParams = {
			content: fields,
			tool_calls: [],
			invalid_tool_calls: [],
			additional_kwargs: kwargs ?? {}
		};
		else {
			initParams = fields;
			const rawToolCalls = initParams.additional_kwargs?.tool_calls;
			const toolCalls = initParams.tool_calls;
			if (!(rawToolCalls == null) && rawToolCalls.length > 0 && (toolCalls === void 0 || toolCalls.length === 0)) console.warn([
				"New LangChain packages are available that more efficiently handle",
				"tool calling.\n\nPlease upgrade your packages to versions that set",
				"message tool calls. e.g., `yarn add @langchain/anthropic`,",
				"yarn add @langchain/openai`, etc."
			].join(" "));
			try {
				if (!(rawToolCalls == null) && toolCalls === void 0) {
					const [toolCalls$1, invalidToolCalls] = defaultToolCallParser(rawToolCalls);
					initParams.tool_calls = toolCalls$1 ?? [];
					initParams.invalid_tool_calls = invalidToolCalls ?? [];
				} else {
					initParams.tool_calls = initParams.tool_calls ?? [];
					initParams.invalid_tool_calls = initParams.invalid_tool_calls ?? [];
				}
			} catch (e) {
				initParams.tool_calls = [];
				initParams.invalid_tool_calls = [];
			}
		}
		super(initParams);
		Object.defineProperty(this, "tool_calls", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "invalid_tool_calls", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		/**
		* If provided, token usage information associated with the message.
		*/
		Object.defineProperty(this, "usage_metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		if (typeof initParams !== "string") {
			this.tool_calls = initParams.tool_calls ?? this.tool_calls;
			this.invalid_tool_calls = initParams.invalid_tool_calls ?? this.invalid_tool_calls;
		}
		this.usage_metadata = initParams.usage_metadata;
	}
	static lc_name() {
		return "AIMessage";
	}
	_getType() {
		return "ai";
	}
	get _printableFields() {
		return {
			...super._printableFields,
			tool_calls: this.tool_calls,
			invalid_tool_calls: this.invalid_tool_calls,
			usage_metadata: this.usage_metadata
		};
	}
};
function isAIMessage(x) {
	return x._getType() === "ai";
}
function isAIMessageChunk(x) {
	return x._getType() === "ai";
}
/**
* Represents a chunk of an AI message, which can be concatenated with
* other AI message chunks.
*/
var AIMessageChunk = class AIMessageChunk extends BaseMessageChunk {
	constructor(fields) {
		let initParams;
		if (typeof fields === "string") initParams = {
			content: fields,
			tool_calls: [],
			invalid_tool_calls: [],
			tool_call_chunks: []
		};
		else if (fields.tool_call_chunks === void 0) initParams = {
			...fields,
			tool_calls: fields.tool_calls ?? [],
			invalid_tool_calls: [],
			tool_call_chunks: [],
			usage_metadata: fields.usage_metadata !== void 0 ? fields.usage_metadata : void 0
		};
		else {
			const toolCalls = [];
			const invalidToolCalls = [];
			for (const toolCallChunk of fields.tool_call_chunks) {
				let parsedArgs = {};
				try {
					parsedArgs = parsePartialJson(toolCallChunk.args || "{}");
					if (parsedArgs === null || typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) throw new Error("Malformed tool call chunk args.");
					toolCalls.push({
						name: toolCallChunk.name ?? "",
						args: parsedArgs,
						id: toolCallChunk.id,
						type: "tool_call"
					});
				} catch (e) {
					invalidToolCalls.push({
						name: toolCallChunk.name,
						args: toolCallChunk.args,
						id: toolCallChunk.id,
						error: "Malformed args.",
						type: "invalid_tool_call"
					});
				}
			}
			initParams = {
				...fields,
				tool_calls: toolCalls,
				invalid_tool_calls: invalidToolCalls,
				usage_metadata: fields.usage_metadata !== void 0 ? fields.usage_metadata : void 0
			};
		}
		super(initParams);
		Object.defineProperty(this, "tool_calls", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "invalid_tool_calls", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "tool_call_chunks", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		/**
		* If provided, token usage information associated with the message.
		*/
		Object.defineProperty(this, "usage_metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.tool_call_chunks = initParams.tool_call_chunks ?? this.tool_call_chunks;
		this.tool_calls = initParams.tool_calls ?? this.tool_calls;
		this.invalid_tool_calls = initParams.invalid_tool_calls ?? this.invalid_tool_calls;
		this.usage_metadata = initParams.usage_metadata;
	}
	get lc_aliases() {
		return {
			...super.lc_aliases,
			tool_calls: "tool_calls",
			invalid_tool_calls: "invalid_tool_calls",
			tool_call_chunks: "tool_call_chunks"
		};
	}
	static lc_name() {
		return "AIMessageChunk";
	}
	_getType() {
		return "ai";
	}
	get _printableFields() {
		return {
			...super._printableFields,
			tool_calls: this.tool_calls,
			tool_call_chunks: this.tool_call_chunks,
			invalid_tool_calls: this.invalid_tool_calls,
			usage_metadata: this.usage_metadata
		};
	}
	concat(chunk) {
		const combinedFields = {
			content: mergeContent(this.content, chunk.content),
			additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
			response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
			tool_call_chunks: [],
			id: this.id ?? chunk.id
		};
		if (this.tool_call_chunks !== void 0 || chunk.tool_call_chunks !== void 0) {
			const rawToolCalls = _mergeLists(this.tool_call_chunks, chunk.tool_call_chunks);
			if (rawToolCalls !== void 0 && rawToolCalls.length > 0) combinedFields.tool_call_chunks = rawToolCalls;
		}
		if (this.usage_metadata !== void 0 || chunk.usage_metadata !== void 0) {
			const inputTokenDetails = {
				...(this.usage_metadata?.input_token_details?.audio !== void 0 || chunk.usage_metadata?.input_token_details?.audio !== void 0) && { audio: (this.usage_metadata?.input_token_details?.audio ?? 0) + (chunk.usage_metadata?.input_token_details?.audio ?? 0) },
				...(this.usage_metadata?.input_token_details?.cache_read !== void 0 || chunk.usage_metadata?.input_token_details?.cache_read !== void 0) && { cache_read: (this.usage_metadata?.input_token_details?.cache_read ?? 0) + (chunk.usage_metadata?.input_token_details?.cache_read ?? 0) },
				...(this.usage_metadata?.input_token_details?.cache_creation !== void 0 || chunk.usage_metadata?.input_token_details?.cache_creation !== void 0) && { cache_creation: (this.usage_metadata?.input_token_details?.cache_creation ?? 0) + (chunk.usage_metadata?.input_token_details?.cache_creation ?? 0) }
			};
			const outputTokenDetails = {
				...(this.usage_metadata?.output_token_details?.audio !== void 0 || chunk.usage_metadata?.output_token_details?.audio !== void 0) && { audio: (this.usage_metadata?.output_token_details?.audio ?? 0) + (chunk.usage_metadata?.output_token_details?.audio ?? 0) },
				...(this.usage_metadata?.output_token_details?.reasoning !== void 0 || chunk.usage_metadata?.output_token_details?.reasoning !== void 0) && { reasoning: (this.usage_metadata?.output_token_details?.reasoning ?? 0) + (chunk.usage_metadata?.output_token_details?.reasoning ?? 0) }
			};
			const left = this.usage_metadata ?? {
				input_tokens: 0,
				output_tokens: 0,
				total_tokens: 0
			};
			const right = chunk.usage_metadata ?? {
				input_tokens: 0,
				output_tokens: 0,
				total_tokens: 0
			};
			const usage_metadata = {
				input_tokens: left.input_tokens + right.input_tokens,
				output_tokens: left.output_tokens + right.output_tokens,
				total_tokens: left.total_tokens + right.total_tokens,
				...Object.keys(inputTokenDetails).length > 0 && { input_token_details: inputTokenDetails },
				...Object.keys(outputTokenDetails).length > 0 && { output_token_details: outputTokenDetails }
			};
			combinedFields.usage_metadata = usage_metadata;
		}
		return new AIMessageChunk(combinedFields);
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/chat.js
/**
* Represents a chat message in a conversation.
*/
var ChatMessage = class ChatMessage extends BaseMessage {
	static lc_name() {
		return "ChatMessage";
	}
	static _chatMessageClass() {
		return ChatMessage;
	}
	constructor(fields, role) {
		if (typeof fields === "string") fields = {
			content: fields,
			role
		};
		super(fields);
		Object.defineProperty(this, "role", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.role = fields.role;
	}
	_getType() {
		return "generic";
	}
	static isInstance(message) {
		return message._getType() === "generic";
	}
	get _printableFields() {
		return {
			...super._printableFields,
			role: this.role
		};
	}
};
/**
* Represents a chunk of a chat message, which can be concatenated with
* other chat message chunks.
*/
var ChatMessageChunk = class ChatMessageChunk extends BaseMessageChunk {
	static lc_name() {
		return "ChatMessageChunk";
	}
	constructor(fields, role) {
		if (typeof fields === "string") fields = {
			content: fields,
			role
		};
		super(fields);
		Object.defineProperty(this, "role", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.role = fields.role;
	}
	_getType() {
		return "generic";
	}
	concat(chunk) {
		return new ChatMessageChunk({
			content: mergeContent(this.content, chunk.content),
			additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
			response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
			role: this.role,
			id: this.id ?? chunk.id
		});
	}
	get _printableFields() {
		return {
			...super._printableFields,
			role: this.role
		};
	}
};
function isChatMessage(x) {
	return x._getType() === "generic";
}
function isChatMessageChunk(x) {
	return x._getType() === "generic";
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/function.js
/**
* Represents a function message in a conversation.
*/
var FunctionMessage = class extends BaseMessage {
	static lc_name() {
		return "FunctionMessage";
	}
	constructor(fields, name) {
		if (typeof fields === "string") fields = {
			content: fields,
			name
		};
		super(fields);
	}
	_getType() {
		return "function";
	}
};
/**
* Represents a chunk of a function message, which can be concatenated
* with other function message chunks.
*/
var FunctionMessageChunk = class FunctionMessageChunk extends BaseMessageChunk {
	static lc_name() {
		return "FunctionMessageChunk";
	}
	_getType() {
		return "function";
	}
	concat(chunk) {
		return new FunctionMessageChunk({
			content: mergeContent(this.content, chunk.content),
			additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
			response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
			name: this.name ?? "",
			id: this.id ?? chunk.id
		});
	}
};
function isFunctionMessage(x) {
	return x._getType() === "function";
}
function isFunctionMessageChunk(x) {
	return x._getType() === "function";
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/human.js
/**
* Represents a human message in a conversation.
*/
var HumanMessage = class extends BaseMessage {
	static lc_name() {
		return "HumanMessage";
	}
	_getType() {
		return "human";
	}
	constructor(fields, kwargs) {
		super(fields, kwargs);
	}
};
/**
* Represents a chunk of a human message, which can be concatenated with
* other human message chunks.
*/
var HumanMessageChunk = class HumanMessageChunk extends BaseMessageChunk {
	static lc_name() {
		return "HumanMessageChunk";
	}
	_getType() {
		return "human";
	}
	constructor(fields, kwargs) {
		super(fields, kwargs);
	}
	concat(chunk) {
		return new HumanMessageChunk({
			content: mergeContent(this.content, chunk.content),
			additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
			response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
			id: this.id ?? chunk.id
		});
	}
};
function isHumanMessage(x) {
	return x.getType() === "human";
}
function isHumanMessageChunk(x) {
	return x.getType() === "human";
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/system.js
/**
* Represents a system message in a conversation.
*/
var SystemMessage = class extends BaseMessage {
	static lc_name() {
		return "SystemMessage";
	}
	_getType() {
		return "system";
	}
	constructor(fields, kwargs) {
		super(fields, kwargs);
	}
};
/**
* Represents a chunk of a system message, which can be concatenated with
* other system message chunks.
*/
var SystemMessageChunk = class SystemMessageChunk extends BaseMessageChunk {
	static lc_name() {
		return "SystemMessageChunk";
	}
	_getType() {
		return "system";
	}
	constructor(fields, kwargs) {
		super(fields, kwargs);
	}
	concat(chunk) {
		return new SystemMessageChunk({
			content: mergeContent(this.content, chunk.content),
			additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
			response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
			id: this.id ?? chunk.id
		});
	}
};
function isSystemMessage(x) {
	return x._getType() === "system";
}
function isSystemMessageChunk(x) {
	return x._getType() === "system";
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/utils.js
function _coerceToolCall(toolCall) {
	if (_isToolCall(toolCall)) return toolCall;
	else if (typeof toolCall.id === "string" && toolCall.type === "function" && typeof toolCall.function === "object" && toolCall.function !== null && "arguments" in toolCall.function && typeof toolCall.function.arguments === "string" && "name" in toolCall.function && typeof toolCall.function.name === "string") return {
		id: toolCall.id,
		args: JSON.parse(toolCall.function.arguments),
		name: toolCall.function.name,
		type: "tool_call"
	};
	else return toolCall;
}
function isSerializedConstructor(x) {
	return typeof x === "object" && x != null && x.lc === 1 && Array.isArray(x.id) && x.kwargs != null && typeof x.kwargs === "object";
}
function _constructMessageFromParams(params) {
	let type;
	let rest;
	if (isSerializedConstructor(params)) {
		const className = params.id.at(-1);
		if (className === "HumanMessage" || className === "HumanMessageChunk") type = "user";
		else if (className === "AIMessage" || className === "AIMessageChunk") type = "assistant";
		else if (className === "SystemMessage" || className === "SystemMessageChunk") type = "system";
		else if (className === "FunctionMessage" || className === "FunctionMessageChunk") type = "function";
		else if (className === "ToolMessage" || className === "ToolMessageChunk") type = "tool";
		else type = "unknown";
		rest = params.kwargs;
	} else {
		const { type: extractedType,...otherParams } = params;
		type = extractedType;
		rest = otherParams;
	}
	if (type === "human" || type === "user") return new HumanMessage(rest);
	else if (type === "ai" || type === "assistant") {
		const { tool_calls: rawToolCalls,...other } = rest;
		if (!Array.isArray(rawToolCalls)) return new AIMessage(rest);
		const tool_calls = rawToolCalls.map(_coerceToolCall);
		return new AIMessage({
			...other,
			tool_calls
		});
	} else if (type === "system") return new SystemMessage(rest);
	else if (type === "developer") return new SystemMessage({
		...rest,
		additional_kwargs: {
			...rest.additional_kwargs,
			__openai_role__: "developer"
		}
	});
	else if (type === "tool" && "tool_call_id" in rest) return new ToolMessage({
		...rest,
		content: rest.content,
		tool_call_id: rest.tool_call_id,
		name: rest.name
	});
	else {
		const error = addLangChainErrorFields(new Error(`Unable to coerce message from array: only human, AI, system, developer, or tool message coercion is currently supported.\n\nReceived: ${JSON.stringify(params, null, 2)}`), "MESSAGE_COERCION_FAILURE");
		throw error;
	}
}
function coerceMessageLikeToMessage(messageLike) {
	if (typeof messageLike === "string") return new HumanMessage(messageLike);
	else if (isBaseMessage(messageLike)) return messageLike;
	if (Array.isArray(messageLike)) {
		const [type, content] = messageLike;
		return _constructMessageFromParams({
			type,
			content
		});
	} else if (_isMessageFieldWithRole(messageLike)) {
		const { role: type,...rest } = messageLike;
		return _constructMessageFromParams({
			...rest,
			type
		});
	} else return _constructMessageFromParams(messageLike);
}
/**
* This function is used by memory classes to get a string representation
* of the chat message history, based on the message content and role.
*/
function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
	const string_messages = [];
	for (const m of messages) {
		let role;
		if (m._getType() === "human") role = humanPrefix;
		else if (m._getType() === "ai") role = aiPrefix;
		else if (m._getType() === "system") role = "System";
		else if (m._getType() === "function") role = "Function";
		else if (m._getType() === "tool") role = "Tool";
		else if (m._getType() === "generic") role = m.role;
		else throw new Error(`Got unsupported message type: ${m._getType()}`);
		const nameStr = m.name ? `${m.name}, ` : "";
		const readableContent = typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2);
		string_messages.push(`${role}: ${nameStr}${readableContent}`);
	}
	return string_messages.join("\n");
}
/**
* Maps messages from an older format (V1) to the current `StoredMessage`
* format. If the message is already in the `StoredMessage` format, it is
* returned as is. Otherwise, it transforms the V1 message into a
* `StoredMessage`. This function is important for maintaining
* compatibility with older message formats.
*/
function mapV1MessageToStoredMessage(message) {
	if (message.data !== void 0) return message;
	else {
		const v1Message = message;
		return {
			type: v1Message.type,
			data: {
				content: v1Message.text,
				role: v1Message.role,
				name: void 0,
				tool_call_id: void 0
			}
		};
	}
}
function mapStoredMessageToChatMessage(message) {
	const storedMessage = mapV1MessageToStoredMessage(message);
	switch (storedMessage.type) {
		case "human": return new HumanMessage(storedMessage.data);
		case "ai": return new AIMessage(storedMessage.data);
		case "system": return new SystemMessage(storedMessage.data);
		case "function":
			if (storedMessage.data.name === void 0) throw new Error("Name must be defined for function messages");
			return new FunctionMessage(storedMessage.data);
		case "tool":
			if (storedMessage.data.tool_call_id === void 0) throw new Error("Tool call ID must be defined for tool messages");
			return new ToolMessage(storedMessage.data);
		case "generic": {
			if (storedMessage.data.role === void 0) throw new Error("Role must be defined for chat messages");
			return new ChatMessage(storedMessage.data);
		}
		default: throw new Error(`Got unexpected type: ${storedMessage.type}`);
	}
}
/**
* Transforms an array of `StoredMessage` instances into an array of
* `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
* function to ensure all messages are in the `StoredMessage` format, then
* creates new instances of the appropriate `BaseMessage` subclass based
* on the type of each message. This function is used to prepare stored
* messages for use in a chat context.
*/
function mapStoredMessagesToChatMessages(messages) {
	return messages.map(mapStoredMessageToChatMessage);
}
/**
* Transforms an array of `BaseMessage` instances into an array of
* `StoredMessage` instances. It does this by calling the `toDict` method
* on each `BaseMessage`, which returns a `StoredMessage`. This function
* is used to prepare chat messages for storage.
*/
function mapChatMessagesToStoredMessages(messages) {
	return messages.map((message) => message.toDict());
}
function convertToChunk(message) {
	const type = message._getType();
	if (type === "human") return new HumanMessageChunk({ ...message });
	else if (type === "ai") {
		let aiChunkFields = { ...message };
		if ("tool_calls" in aiChunkFields) aiChunkFields = {
			...aiChunkFields,
			tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
				...tc,
				type: "tool_call_chunk",
				index: void 0,
				args: JSON.stringify(tc.args)
			}))
		};
		return new AIMessageChunk({ ...aiChunkFields });
	} else if (type === "system") return new SystemMessageChunk({ ...message });
	else if (type === "function") return new FunctionMessageChunk({ ...message });
	else if (ChatMessage.isInstance(message)) return new ChatMessageChunk({ ...message });
	else throw new Error("Unknown message type.");
}

//#endregion
//#region node_modules/.pnpm/langsmith@0.3.30_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/langsmith/dist/singletons/traceable.js
var MockAsyncLocalStorage$1 = class {
	getStore() {
		return void 0;
	}
	run(_, callback) {
		return callback();
	}
};
const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
const mockAsyncLocalStorage$1 = new MockAsyncLocalStorage$1();
var AsyncLocalStorageProvider$1 = class {
	getInstance() {
		return globalThis[TRACING_ALS_KEY] ?? mockAsyncLocalStorage$1;
	}
	initializeGlobalInstance(instance) {
		if (globalThis[TRACING_ALS_KEY] === void 0) globalThis[TRACING_ALS_KEY] = instance;
	}
};
const AsyncLocalStorageProviderSingleton$1 = new AsyncLocalStorageProvider$1();
function getCurrentRunTree(permitAbsentRunTree = false) {
	const runTree = AsyncLocalStorageProviderSingleton$1.getInstance().getStore();
	if (!permitAbsentRunTree && !isRunTree(runTree)) throw new Error("Could not get the current run tree.\n\nPlease make sure you are calling this method within a traceable function and that tracing is enabled.");
	return runTree;
}
const ROOT = Symbol.for("langsmith:traceable:root");
function isTraceableFunction(x) {
	return typeof x === "function" && "langsmith:traceable" in x;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/singletons/tracer.js
let client;
const getDefaultLangChainClientSingleton = () => {
	if (client === void 0) {
		const clientParams = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false" ? { blockOnRootRunFinalization: true } : {};
		client = new Client(clientParams);
	}
	return client;
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tracers/tracer_langchain.js
var tracer_langchain_exports = {};
__export(tracer_langchain_exports, { LangChainTracer: () => LangChainTracer });
var LangChainTracer = class LangChainTracer extends BaseTracer {
	constructor(fields = {}) {
		super(fields);
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "langchain_tracer"
		});
		Object.defineProperty(this, "projectName", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "exampleId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "client", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		const { exampleId, projectName, client: client$1 } = fields;
		this.projectName = projectName ?? getEnvironmentVariable("LANGCHAIN_PROJECT") ?? getEnvironmentVariable("LANGCHAIN_SESSION");
		this.exampleId = exampleId;
		this.client = client$1 ?? getDefaultLangChainClientSingleton();
		const traceableTree = LangChainTracer.getTraceableRunTree();
		if (traceableTree) this.updateFromRunTree(traceableTree);
	}
	async _convertToCreate(run, example_id = void 0) {
		return {
			...run,
			extra: {
				...run.extra,
				runtime: await getRuntimeEnvironment()
			},
			child_runs: void 0,
			session_name: this.projectName,
			reference_example_id: run.parent_run_id ? void 0 : example_id
		};
	}
	async persistRun(_run) {}
	async onRunCreate(run) {
		const persistedRun = await this._convertToCreate(run, this.exampleId);
		await this.client.createRun(persistedRun);
	}
	async onRunUpdate(run) {
		const runUpdate = {
			end_time: run.end_time,
			error: run.error,
			outputs: run.outputs,
			events: run.events,
			inputs: run.inputs,
			trace_id: run.trace_id,
			dotted_order: run.dotted_order,
			parent_run_id: run.parent_run_id,
			extra: run.extra,
			session_name: this.projectName
		};
		await this.client.updateRun(run.id, runUpdate);
	}
	getRun(id) {
		return this.runMap.get(id);
	}
	updateFromRunTree(runTree) {
		let rootRun = runTree;
		const visited = /* @__PURE__ */ new Set();
		while (rootRun.parent_run) {
			if (visited.has(rootRun.id)) break;
			visited.add(rootRun.id);
			if (!rootRun.parent_run) break;
			rootRun = rootRun.parent_run;
		}
		visited.clear();
		const queue$1 = [rootRun];
		while (queue$1.length > 0) {
			const current = queue$1.shift();
			if (!current || visited.has(current.id)) continue;
			visited.add(current.id);
			this.runMap.set(current.id, current);
			if (current.child_runs) queue$1.push(...current.child_runs);
		}
		this.client = runTree.client ?? this.client;
		this.projectName = runTree.project_name ?? this.projectName;
		this.exampleId = runTree.reference_example_id ?? this.exampleId;
	}
	convertToRunTree(id) {
		const runTreeMap = {};
		const runTreeList = [];
		for (const [id$1, run] of this.runMap) {
			const runTree = new RunTree({
				...run,
				child_runs: [],
				parent_run: void 0,
				client: this.client,
				project_name: this.projectName,
				reference_example_id: this.exampleId,
				tracingEnabled: true
			});
			runTreeMap[id$1] = runTree;
			runTreeList.push([id$1, run.dotted_order]);
		}
		runTreeList.sort((a, b) => {
			if (!a[1] || !b[1]) return 0;
			return a[1].localeCompare(b[1]);
		});
		for (const [id$1] of runTreeList) {
			const run = this.runMap.get(id$1);
			const runTree = runTreeMap[id$1];
			if (!run || !runTree) continue;
			if (run.parent_run_id) {
				const parentRunTree = runTreeMap[run.parent_run_id];
				if (parentRunTree) {
					parentRunTree.child_runs.push(runTree);
					runTree.parent_run = parentRunTree;
				}
			}
		}
		return runTreeMap[id];
	}
	static getTraceableRunTree() {
		try {
			return getCurrentRunTree(true);
		} catch {
			return void 0;
		}
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/singletons/callbacks.js
var import_dist$1 = __toESM(require_dist(), 1);
let queue;
/**
* Creates a queue using the p-queue library. The queue is configured to
* auto-start and has a concurrency of 1, meaning it will process tasks
* one at a time.
*/
function createQueue() {
	const PQueue$1 = "default" in import_dist$1.default ? import_dist$1.default.default : import_dist$1.default;
	return new PQueue$1({
		autoStart: true,
		concurrency: 1
	});
}
function getQueue() {
	if (typeof queue === "undefined") queue = createQueue();
	return queue;
}
/**
* Consume a promise, either adding it to the queue or waiting for it to resolve
* @param promiseFn Promise to consume
* @param wait Whether to wait for the promise to resolve or resolve immediately
*/
async function consumeCallback(promiseFn, wait) {
	if (wait === true) {
		const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
		if (asyncLocalStorageInstance !== void 0) await asyncLocalStorageInstance.run(void 0, async () => promiseFn());
		else await promiseFn();
	} else {
		queue = getQueue();
		queue.add(async () => {
			const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
			if (asyncLocalStorageInstance !== void 0) await asyncLocalStorageInstance.run(void 0, async () => promiseFn());
			else await promiseFn();
		});
	}
}
/**
* Waits for all promises in the queue to resolve. If the queue is
* undefined, it immediately resolves a promise.
*/
function awaitAllCallbacks() {
	return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/callbacks/promises.js
var promises_exports = {};
__export(promises_exports, {
	awaitAllCallbacks: () => awaitAllCallbacks,
	consumeCallback: () => consumeCallback
});

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/callbacks.js
const isTracingEnabled = (tracingEnabled) => {
	if (tracingEnabled !== void 0) return tracingEnabled;
	const envVars = [
		"LANGSMITH_TRACING_V2",
		"LANGCHAIN_TRACING_V2",
		"LANGSMITH_TRACING",
		"LANGCHAIN_TRACING"
	];
	return !!envVars.find((envVar) => getEnvironmentVariable(envVar) === "true");
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/singletons/async_local_storage/context.js
/**
* Get the value of a previously set context variable. Context variables
* are scoped to any child runnables called by the current runnable,
* or globally if set outside of any runnable.
*
* @remarks
* This function is only supported in environments that support AsyncLocalStorage,
* including Node.js, Deno, and Cloudflare Workers.
*
* @example
* ```ts
* import { RunnableLambda } from "@langchain/core/runnables";
* import {
*   getContextVariable,
*   setContextVariable
* } from "@langchain/core/context";
*
* const nested = RunnableLambda.from(() => {
*   // "bar" because it was set by a parent
*   console.log(getContextVariable("foo"));
*
*   // Override to "baz", but only for child runnables
*   setContextVariable("foo", "baz");
*
*   // Now "baz", but only for child runnables
*   return getContextVariable("foo");
* });
*
* const runnable = RunnableLambda.from(async () => {
*   // Set a context variable named "foo"
*   setContextVariable("foo", "bar");
*
*   const res = await nested.invoke({});
*
*   // Still "bar" since child changes do not affect parents
*   console.log(getContextVariable("foo"));
*
*   return res;
* });
*
* // undefined, because context variable has not been set yet
* console.log(getContextVariable("foo"));
*
* // Final return value is "baz"
* const result = await runnable.invoke({});
* ```
*
* @param name The name of the context variable.
*/
function getContextVariable(name) {
	const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
	if (asyncLocalStorageInstance === void 0) return void 0;
	const runTree = asyncLocalStorageInstance.getStore();
	return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
}
const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/callbacks/manager.js
var manager_exports = {};
__export(manager_exports, {
	BaseCallbackManager: () => BaseCallbackManager,
	BaseRunManager: () => BaseRunManager,
	CallbackManager: () => CallbackManager,
	CallbackManagerForChainRun: () => CallbackManagerForChainRun,
	CallbackManagerForLLMRun: () => CallbackManagerForLLMRun,
	CallbackManagerForRetrieverRun: () => CallbackManagerForRetrieverRun,
	CallbackManagerForToolRun: () => CallbackManagerForToolRun,
	TraceGroup: () => TraceGroup,
	ensureHandler: () => ensureHandler,
	parseCallbackConfigArg: () => parseCallbackConfigArg,
	traceAsGroup: () => traceAsGroup
});
function parseCallbackConfigArg(arg) {
	if (!arg) return {};
	else if (Array.isArray(arg) || "name" in arg) return { callbacks: arg };
	else return arg;
}
/**
* Manage callbacks from different components of LangChain.
*/
var BaseCallbackManager = class {
	setHandler(handler) {
		return this.setHandlers([handler]);
	}
};
/**
* Base class for run manager in LangChain.
*/
var BaseRunManager = class {
	constructor(runId, handlers, inheritableHandlers, tags, inheritableTags, metadata, inheritableMetadata, _parentRunId) {
		Object.defineProperty(this, "runId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: runId
		});
		Object.defineProperty(this, "handlers", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: handlers
		});
		Object.defineProperty(this, "inheritableHandlers", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: inheritableHandlers
		});
		Object.defineProperty(this, "tags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: tags
		});
		Object.defineProperty(this, "inheritableTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: inheritableTags
		});
		Object.defineProperty(this, "metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: metadata
		});
		Object.defineProperty(this, "inheritableMetadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: inheritableMetadata
		});
		Object.defineProperty(this, "_parentRunId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: _parentRunId
		});
	}
	get parentRunId() {
		return this._parentRunId;
	}
	async handleText(text) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			try {
				await handler.handleText?.(text, this.runId, this._parentRunId, this.tags);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleText: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
	async handleCustomEvent(eventName, data, _runId, _tags, _metadata) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			try {
				await handler.handleCustomEvent?.(eventName, data, this.runId, this.tags, this.metadata);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleCustomEvent: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
};
/**
* Manages callbacks for retriever runs.
*/
var CallbackManagerForRetrieverRun = class extends BaseRunManager {
	getChild(tag) {
		const manager = new CallbackManager(this.runId);
		manager.setHandlers(this.inheritableHandlers);
		manager.addTags(this.inheritableTags);
		manager.addMetadata(this.inheritableMetadata);
		if (tag) manager.addTags([tag], false);
		return manager;
	}
	async handleRetrieverEnd(documents) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreRetriever) try {
				await handler.handleRetrieverEnd?.(documents, this.runId, this._parentRunId, this.tags);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleRetriever`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
	async handleRetrieverError(err) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreRetriever) try {
				await handler.handleRetrieverError?.(err, this.runId, this._parentRunId, this.tags);
			} catch (error) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleRetrieverError: ${error}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
};
var CallbackManagerForLLMRun = class extends BaseRunManager {
	async handleLLMNewToken(token, idx, _runId, _parentRunId, _tags, fields) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreLLM) try {
				await handler.handleLLMNewToken?.(token, idx ?? {
					prompt: 0,
					completion: 0
				}, this.runId, this._parentRunId, this.tags, fields);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleLLMNewToken: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
	async handleLLMError(err, _runId, _parentRunId, _tags, extraParams) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreLLM) try {
				await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags, extraParams);
			} catch (err$1) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleLLMError: ${err$1}`);
				if (handler.raiseError) throw err$1;
			}
		}, handler.awaitHandlers)));
	}
	async handleLLMEnd(output, _runId, _parentRunId, _tags, extraParams) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreLLM) try {
				await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags, extraParams);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleLLMEnd: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
};
var CallbackManagerForChainRun = class extends BaseRunManager {
	getChild(tag) {
		const manager = new CallbackManager(this.runId);
		manager.setHandlers(this.inheritableHandlers);
		manager.addTags(this.inheritableTags);
		manager.addMetadata(this.inheritableMetadata);
		if (tag) manager.addTags([tag], false);
		return manager;
	}
	async handleChainError(err, _runId, _parentRunId, _tags, kwargs) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreChain) try {
				await handler.handleChainError?.(err, this.runId, this._parentRunId, this.tags, kwargs);
			} catch (err$1) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleChainError: ${err$1}`);
				if (handler.raiseError) throw err$1;
			}
		}, handler.awaitHandlers)));
	}
	async handleChainEnd(output, _runId, _parentRunId, _tags, kwargs) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreChain) try {
				await handler.handleChainEnd?.(output, this.runId, this._parentRunId, this.tags, kwargs);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleChainEnd: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
	async handleAgentAction(action) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreAgent) try {
				await handler.handleAgentAction?.(action, this.runId, this._parentRunId, this.tags);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleAgentAction: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
	async handleAgentEnd(action) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreAgent) try {
				await handler.handleAgentEnd?.(action, this.runId, this._parentRunId, this.tags);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleAgentEnd: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
};
var CallbackManagerForToolRun = class extends BaseRunManager {
	getChild(tag) {
		const manager = new CallbackManager(this.runId);
		manager.setHandlers(this.inheritableHandlers);
		manager.addTags(this.inheritableTags);
		manager.addMetadata(this.inheritableMetadata);
		if (tag) manager.addTags([tag], false);
		return manager;
	}
	async handleToolError(err) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreAgent) try {
				await handler.handleToolError?.(err, this.runId, this._parentRunId, this.tags);
			} catch (err$1) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleToolError: ${err$1}`);
				if (handler.raiseError) throw err$1;
			}
		}, handler.awaitHandlers)));
	}
	async handleToolEnd(output) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreAgent) try {
				await handler.handleToolEnd?.(output, this.runId, this._parentRunId, this.tags);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleToolEnd: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
};
/**
* @example
* ```typescript
* const prompt = PromptTemplate.fromTemplate("What is the answer to {question}?");
*
* // Example of using LLMChain with OpenAI and a simple prompt
* const chain = new LLMChain({
*   llm: new ChatOpenAI({ temperature: 0.9 }),
*   prompt,
* });
*
* // Running the chain with a single question
* const result = await chain.call({
*   question: "What is the airspeed velocity of an unladen swallow?",
* });
* console.log("The answer is:", result);
* ```
*/
var CallbackManager = class CallbackManager extends BaseCallbackManager {
	constructor(parentRunId, options) {
		super();
		Object.defineProperty(this, "handlers", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "inheritableHandlers", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "tags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "inheritableTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: {}
		});
		Object.defineProperty(this, "inheritableMetadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: {}
		});
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "callback_manager"
		});
		Object.defineProperty(this, "_parentRunId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.handlers = options?.handlers ?? this.handlers;
		this.inheritableHandlers = options?.inheritableHandlers ?? this.inheritableHandlers;
		this.tags = options?.tags ?? this.tags;
		this.inheritableTags = options?.inheritableTags ?? this.inheritableTags;
		this.metadata = options?.metadata ?? this.metadata;
		this.inheritableMetadata = options?.inheritableMetadata ?? this.inheritableMetadata;
		this._parentRunId = parentRunId;
	}
	/**
	* Gets the parent run ID, if any.
	*
	* @returns The parent run ID.
	*/
	getParentRunId() {
		return this._parentRunId;
	}
	async handleLLMStart(llm, prompts, runId = void 0, _parentRunId = void 0, extraParams = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
		return Promise.all(prompts.map(async (prompt, idx) => {
			const runId_ = idx === 0 && runId ? runId : v4_default();
			await Promise.all(this.handlers.map((handler) => {
				if (handler.ignoreLLM) return;
				if (isBaseTracer(handler)) handler._createRunForLLMStart(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
				return consumeCallback(async () => {
					try {
						await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
					} catch (err) {
						const logFunction = handler.raiseError ? console.error : console.warn;
						logFunction(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`);
						if (handler.raiseError) throw err;
					}
				}, handler.awaitHandlers);
			}));
			return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
		}));
	}
	async handleChatModelStart(llm, messages, runId = void 0, _parentRunId = void 0, extraParams = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
		return Promise.all(messages.map(async (messageGroup, idx) => {
			const runId_ = idx === 0 && runId ? runId : v4_default();
			await Promise.all(this.handlers.map((handler) => {
				if (handler.ignoreLLM) return;
				if (isBaseTracer(handler)) handler._createRunForChatModelStart(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
				return consumeCallback(async () => {
					try {
						if (handler.handleChatModelStart) await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
						else if (handler.handleLLMStart) {
							const messageString = getBufferString(messageGroup);
							await handler.handleLLMStart?.(llm, [messageString], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
						}
					} catch (err) {
						const logFunction = handler.raiseError ? console.error : console.warn;
						logFunction(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`);
						if (handler.raiseError) throw err;
					}
				}, handler.awaitHandlers);
			}));
			return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
		}));
	}
	async handleChainStart(chain, inputs, runId = v4_default(), runType = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
		await Promise.all(this.handlers.map((handler) => {
			if (handler.ignoreChain) return;
			if (isBaseTracer(handler)) handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
			return consumeCallback(async () => {
				try {
					await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
				} catch (err) {
					const logFunction = handler.raiseError ? console.error : console.warn;
					logFunction(`Error in handler ${handler.constructor.name}, handleChainStart: ${err}`);
					if (handler.raiseError) throw err;
				}
			}, handler.awaitHandlers);
		}));
		return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
	}
	async handleToolStart(tool, input, runId = v4_default(), _parentRunId = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
		await Promise.all(this.handlers.map((handler) => {
			if (handler.ignoreAgent) return;
			if (isBaseTracer(handler)) handler._createRunForToolStart(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
			return consumeCallback(async () => {
				try {
					await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
				} catch (err) {
					const logFunction = handler.raiseError ? console.error : console.warn;
					logFunction(`Error in handler ${handler.constructor.name}, handleToolStart: ${err}`);
					if (handler.raiseError) throw err;
				}
			}, handler.awaitHandlers);
		}));
		return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
	}
	async handleRetrieverStart(retriever, query, runId = v4_default(), _parentRunId = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
		await Promise.all(this.handlers.map((handler) => {
			if (handler.ignoreRetriever) return;
			if (isBaseTracer(handler)) handler._createRunForRetrieverStart(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
			return consumeCallback(async () => {
				try {
					await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
				} catch (err) {
					const logFunction = handler.raiseError ? console.error : console.warn;
					logFunction(`Error in handler ${handler.constructor.name}, handleRetrieverStart: ${err}`);
					if (handler.raiseError) throw err;
				}
			}, handler.awaitHandlers);
		}));
		return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
	}
	async handleCustomEvent(eventName, data, runId, _tags, _metadata) {
		await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
			if (!handler.ignoreCustomEvent) try {
				await handler.handleCustomEvent?.(eventName, data, runId, this.tags, this.metadata);
			} catch (err) {
				const logFunction = handler.raiseError ? console.error : console.warn;
				logFunction(`Error in handler ${handler.constructor.name}, handleCustomEvent: ${err}`);
				if (handler.raiseError) throw err;
			}
		}, handler.awaitHandlers)));
	}
	addHandler(handler, inherit = true) {
		this.handlers.push(handler);
		if (inherit) this.inheritableHandlers.push(handler);
	}
	removeHandler(handler) {
		this.handlers = this.handlers.filter((_handler) => _handler !== handler);
		this.inheritableHandlers = this.inheritableHandlers.filter((_handler) => _handler !== handler);
	}
	setHandlers(handlers, inherit = true) {
		this.handlers = [];
		this.inheritableHandlers = [];
		for (const handler of handlers) this.addHandler(handler, inherit);
	}
	addTags(tags, inherit = true) {
		this.removeTags(tags);
		this.tags.push(...tags);
		if (inherit) this.inheritableTags.push(...tags);
	}
	removeTags(tags) {
		this.tags = this.tags.filter((tag) => !tags.includes(tag));
		this.inheritableTags = this.inheritableTags.filter((tag) => !tags.includes(tag));
	}
	addMetadata(metadata, inherit = true) {
		this.metadata = {
			...this.metadata,
			...metadata
		};
		if (inherit) this.inheritableMetadata = {
			...this.inheritableMetadata,
			...metadata
		};
	}
	removeMetadata(metadata) {
		for (const key of Object.keys(metadata)) {
			delete this.metadata[key];
			delete this.inheritableMetadata[key];
		}
	}
	copy(additionalHandlers = [], inherit = true) {
		const manager = new CallbackManager(this._parentRunId);
		for (const handler of this.handlers) {
			const inheritable = this.inheritableHandlers.includes(handler);
			manager.addHandler(handler, inheritable);
		}
		for (const tag of this.tags) {
			const inheritable = this.inheritableTags.includes(tag);
			manager.addTags([tag], inheritable);
		}
		for (const key of Object.keys(this.metadata)) {
			const inheritable = Object.keys(this.inheritableMetadata).includes(key);
			manager.addMetadata({ [key]: this.metadata[key] }, inheritable);
		}
		for (const handler of additionalHandlers) {
			if (manager.handlers.filter((h) => h.name === "console_callback_handler").some((h) => h.name === handler.name)) continue;
			manager.addHandler(handler, inherit);
		}
		return manager;
	}
	static fromHandlers(handlers) {
		class Handler extends BaseCallbackHandler {
			constructor() {
				super();
				Object.defineProperty(this, "name", {
					enumerable: true,
					configurable: true,
					writable: true,
					value: v4_default()
				});
				Object.assign(this, handlers);
			}
		}
		const manager = new this();
		manager.addHandler(new Handler());
		return manager;
	}
	static configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
		return this._configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options);
	}
	static _configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
		let callbackManager;
		if (inheritableHandlers || localHandlers) {
			if (Array.isArray(inheritableHandlers) || !inheritableHandlers) {
				callbackManager = new CallbackManager();
				callbackManager.setHandlers(inheritableHandlers?.map(ensureHandler) ?? [], true);
			} else callbackManager = inheritableHandlers;
			callbackManager = callbackManager.copy(Array.isArray(localHandlers) ? localHandlers.map(ensureHandler) : localHandlers?.handlers, false);
		}
		const verboseEnabled = getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" || options?.verbose;
		const tracingV2Enabled = LangChainTracer.getTraceableRunTree()?.tracingEnabled || isTracingEnabled();
		const tracingEnabled = tracingV2Enabled || (getEnvironmentVariable("LANGCHAIN_TRACING") ?? false);
		if (verboseEnabled || tracingEnabled) {
			if (!callbackManager) callbackManager = new CallbackManager();
			if (verboseEnabled && !callbackManager.handlers.some((handler) => handler.name === ConsoleCallbackHandler.prototype.name)) {
				const consoleHandler = new ConsoleCallbackHandler();
				callbackManager.addHandler(consoleHandler, true);
			}
			if (tracingEnabled && !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) {
				if (tracingV2Enabled) {
					const tracerV2 = new LangChainTracer();
					callbackManager.addHandler(tracerV2, true);
					callbackManager._parentRunId = LangChainTracer.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
				}
			}
		}
		for (const { contextVar, inheritable = true, handlerClass, envVar } of _getConfigureHooks()) {
			const createIfNotInContext = envVar && getEnvironmentVariable(envVar) === "true" && handlerClass;
			let handler;
			const contextVarValue = contextVar !== void 0 ? getContextVariable(contextVar) : void 0;
			if (contextVarValue && isBaseCallbackHandler(contextVarValue)) handler = contextVarValue;
			else if (createIfNotInContext) handler = new handlerClass({});
			if (handler !== void 0) {
				if (!callbackManager) callbackManager = new CallbackManager();
				if (!callbackManager.handlers.some((h) => h.name === handler.name)) callbackManager.addHandler(handler, inheritable);
			}
		}
		if (inheritableTags || localTags) {
			if (callbackManager) {
				callbackManager.addTags(inheritableTags ?? []);
				callbackManager.addTags(localTags ?? [], false);
			}
		}
		if (inheritableMetadata || localMetadata) {
			if (callbackManager) {
				callbackManager.addMetadata(inheritableMetadata ?? {});
				callbackManager.addMetadata(localMetadata ?? {}, false);
			}
		}
		return callbackManager;
	}
};
function ensureHandler(handler) {
	if ("name" in handler) return handler;
	return BaseCallbackHandler.fromMethods(handler);
}
/**
* @deprecated Use [`traceable`](https://docs.smith.langchain.com/observability/how_to_guides/tracing/annotate_code)
* from "langsmith" instead.
*/
var TraceGroup = class {
	constructor(groupName, options) {
		Object.defineProperty(this, "groupName", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: groupName
		});
		Object.defineProperty(this, "options", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: options
		});
		Object.defineProperty(this, "runManager", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
	}
	async getTraceGroupCallbackManager(group_name, inputs, options) {
		const cb = new LangChainTracer(options);
		const cm = await CallbackManager.configure([cb]);
		const runManager = await cm?.handleChainStart({
			lc: 1,
			type: "not_implemented",
			id: [
				"langchain",
				"callbacks",
				"groups",
				group_name
			]
		}, inputs ?? {});
		if (!runManager) throw new Error("Failed to create run group callback manager.");
		return runManager;
	}
	async start(inputs) {
		if (!this.runManager) this.runManager = await this.getTraceGroupCallbackManager(this.groupName, inputs, this.options);
		return this.runManager.getChild();
	}
	async error(err) {
		if (this.runManager) {
			await this.runManager.handleChainError(err);
			this.runManager = void 0;
		}
	}
	async end(output) {
		if (this.runManager) {
			await this.runManager.handleChainEnd(output ?? {});
			this.runManager = void 0;
		}
	}
};
function _coerceToDict$1(value, defaultKey) {
	return value && !Array.isArray(value) && typeof value === "object" ? value : { [defaultKey]: value };
}
async function traceAsGroup(groupOptions, enclosedCode, ...args) {
	const traceGroup = new TraceGroup(groupOptions.name, groupOptions);
	const callbackManager = await traceGroup.start({ ...args });
	try {
		const result = await enclosedCode(callbackManager, ...args);
		await traceGroup.end(_coerceToDict$1(result, "output"));
		return result;
	} catch (err) {
		await traceGroup.error(err);
		throw err;
	}
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/singletons/async_local_storage/index.js
var MockAsyncLocalStorage = class {
	getStore() {
		return void 0;
	}
	run(_store, callback) {
		return callback();
	}
	enterWith(_store) {
		return void 0;
	}
};
const mockAsyncLocalStorage = new MockAsyncLocalStorage();
const LC_CHILD_KEY = Symbol.for("lc:child_config");
var AsyncLocalStorageProvider = class {
	getInstance() {
		return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;
	}
	getRunnableConfig() {
		const storage = this.getInstance();
		return storage.getStore()?.extra?.[LC_CHILD_KEY];
	}
	runWithConfig(config, callback, avoidCreatingRootRunTree) {
		const callbackManager = CallbackManager._configureSync(config?.callbacks, void 0, config?.tags, void 0, config?.metadata);
		const storage = this.getInstance();
		const previousValue = storage.getStore();
		const parentRunId = callbackManager?.getParentRunId();
		const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
		let runTree;
		if (langChainTracer && parentRunId) runTree = langChainTracer.convertToRunTree(parentRunId);
		else if (!avoidCreatingRootRunTree) runTree = new RunTree({
			name: "<runnable_lambda>",
			tracingEnabled: false
		});
		if (runTree) runTree.extra = {
			...runTree.extra,
			[LC_CHILD_KEY]: config
		};
		if (previousValue !== void 0 && previousValue[_CONTEXT_VARIABLES_KEY] !== void 0) {
			if (runTree === void 0) runTree = {};
			runTree[_CONTEXT_VARIABLES_KEY] = previousValue[_CONTEXT_VARIABLES_KEY];
		}
		return storage.run(runTree, callback);
	}
	initializeGlobalInstance(instance) {
		if (getGlobalAsyncLocalStorageInstance() === void 0) setGlobalAsyncLocalStorageInstance(instance);
	}
};
const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/helpers/util.js
var util;
(function(util$1) {
	util$1.assertEqual = (_) => {};
	function assertIs(_arg) {}
	util$1.assertIs = assertIs;
	function assertNever(_x) {
		throw new Error();
	}
	util$1.assertNever = assertNever;
	util$1.arrayToEnum = (items) => {
		const obj = {};
		for (const item of items) obj[item] = item;
		return obj;
	};
	util$1.getValidEnumValues = (obj) => {
		const validKeys = util$1.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
		const filtered = {};
		for (const k of validKeys) filtered[k] = obj[k];
		return util$1.objectValues(filtered);
	};
	util$1.objectValues = (obj) => {
		return util$1.objectKeys(obj).map(function(e) {
			return obj[e];
		});
	};
	util$1.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
		const keys = [];
		for (const key in object) if (Object.prototype.hasOwnProperty.call(object, key)) keys.push(key);
		return keys;
	};
	util$1.find = (arr$1, checker) => {
		for (const item of arr$1) if (checker(item)) return item;
		return void 0;
	};
	util$1.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
	function joinValues(array, separator = " | ") {
		return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
	}
	util$1.joinValues = joinValues;
	util$1.jsonStringifyReplacer = (_, value) => {
		if (typeof value === "bigint") return value.toString();
		return value;
	};
})(util || (util = {}));
var objectUtil;
(function(objectUtil$1) {
	objectUtil$1.mergeShapes = (first, second) => {
		return {
			...first,
			...second
		};
	};
})(objectUtil || (objectUtil = {}));
const ZodParsedType = util.arrayToEnum([
	"string",
	"nan",
	"number",
	"integer",
	"float",
	"boolean",
	"date",
	"bigint",
	"symbol",
	"function",
	"undefined",
	"null",
	"array",
	"object",
	"unknown",
	"promise",
	"void",
	"never",
	"map",
	"set"
]);
const getParsedType = (data) => {
	const t$5 = typeof data;
	switch (t$5) {
		case "undefined": return ZodParsedType.undefined;
		case "string": return ZodParsedType.string;
		case "number": return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
		case "boolean": return ZodParsedType.boolean;
		case "function": return ZodParsedType.function;
		case "bigint": return ZodParsedType.bigint;
		case "symbol": return ZodParsedType.symbol;
		case "object":
			if (Array.isArray(data)) return ZodParsedType.array;
			if (data === null) return ZodParsedType.null;
			if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") return ZodParsedType.promise;
			if (typeof Map !== "undefined" && data instanceof Map) return ZodParsedType.map;
			if (typeof Set !== "undefined" && data instanceof Set) return ZodParsedType.set;
			if (typeof Date !== "undefined" && data instanceof Date) return ZodParsedType.date;
			return ZodParsedType.object;
		default: return ZodParsedType.unknown;
	}
};

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/ZodError.js
const ZodIssueCode = util.arrayToEnum([
	"invalid_type",
	"invalid_literal",
	"custom",
	"invalid_union",
	"invalid_union_discriminator",
	"invalid_enum_value",
	"unrecognized_keys",
	"invalid_arguments",
	"invalid_return_type",
	"invalid_date",
	"invalid_string",
	"too_small",
	"too_big",
	"invalid_intersection_types",
	"not_multiple_of",
	"not_finite"
]);
var ZodError = class ZodError extends Error {
	get errors() {
		return this.issues;
	}
	constructor(issues) {
		super();
		this.issues = [];
		this.addIssue = (sub) => {
			this.issues = [...this.issues, sub];
		};
		this.addIssues = (subs = []) => {
			this.issues = [...this.issues, ...subs];
		};
		const actualProto = new.target.prototype;
		if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
		else this.__proto__ = actualProto;
		this.name = "ZodError";
		this.issues = issues;
	}
	format(_mapper) {
		const mapper = _mapper || function(issue) {
			return issue.message;
		};
		const fieldErrors = { _errors: [] };
		const processError = (error) => {
			for (const issue of error.issues) if (issue.code === "invalid_union") issue.unionErrors.map(processError);
			else if (issue.code === "invalid_return_type") processError(issue.returnTypeError);
			else if (issue.code === "invalid_arguments") processError(issue.argumentsError);
			else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
			else {
				let curr = fieldErrors;
				let i = 0;
				while (i < issue.path.length) {
					const el = issue.path[i];
					const terminal = i === issue.path.length - 1;
					if (!terminal) curr[el] = curr[el] || { _errors: [] };
					else {
						curr[el] = curr[el] || { _errors: [] };
						curr[el]._errors.push(mapper(issue));
					}
					curr = curr[el];
					i++;
				}
			}
		};
		processError(this);
		return fieldErrors;
	}
	static assert(value) {
		if (!(value instanceof ZodError)) throw new Error(`Not a ZodError: ${value}`);
	}
	toString() {
		return this.message;
	}
	get message() {
		return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
	}
	get isEmpty() {
		return this.issues.length === 0;
	}
	flatten(mapper = (issue) => issue.message) {
		const fieldErrors = {};
		const formErrors = [];
		for (const sub of this.issues) if (sub.path.length > 0) {
			fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
			fieldErrors[sub.path[0]].push(mapper(sub));
		} else formErrors.push(mapper(sub));
		return {
			formErrors,
			fieldErrors
		};
	}
	get formErrors() {
		return this.flatten();
	}
};
ZodError.create = (issues) => {
	const error = new ZodError(issues);
	return error;
};

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/locales/en.js
const errorMap = (issue, _ctx) => {
	let message;
	switch (issue.code) {
		case ZodIssueCode.invalid_type:
			if (issue.received === ZodParsedType.undefined) message = "Required";
			else message = `Expected ${issue.expected}, received ${issue.received}`;
			break;
		case ZodIssueCode.invalid_literal:
			message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
			break;
		case ZodIssueCode.unrecognized_keys:
			message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
			break;
		case ZodIssueCode.invalid_union:
			message = `Invalid input`;
			break;
		case ZodIssueCode.invalid_union_discriminator:
			message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
			break;
		case ZodIssueCode.invalid_enum_value:
			message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
			break;
		case ZodIssueCode.invalid_arguments:
			message = `Invalid function arguments`;
			break;
		case ZodIssueCode.invalid_return_type:
			message = `Invalid function return type`;
			break;
		case ZodIssueCode.invalid_date:
			message = `Invalid date`;
			break;
		case ZodIssueCode.invalid_string:
			if (typeof issue.validation === "object") if ("includes" in issue.validation) {
				message = `Invalid input: must include "${issue.validation.includes}"`;
				if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
			} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
			else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
			else util.assertNever(issue.validation);
			else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
			else message = "Invalid";
			break;
		case ZodIssueCode.too_small:
			if (issue.type === "array") message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
			else if (issue.type === "string") message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
			else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
			else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
			else message = "Invalid input";
			break;
		case ZodIssueCode.too_big:
			if (issue.type === "array") message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
			else if (issue.type === "string") message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
			else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
			else if (issue.type === "bigint") message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
			else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
			else message = "Invalid input";
			break;
		case ZodIssueCode.custom:
			message = `Invalid input`;
			break;
		case ZodIssueCode.invalid_intersection_types:
			message = `Intersection results could not be merged`;
			break;
		case ZodIssueCode.not_multiple_of:
			message = `Number must be a multiple of ${issue.multipleOf}`;
			break;
		case ZodIssueCode.not_finite:
			message = "Number must be finite";
			break;
		default:
			message = _ctx.defaultError;
			util.assertNever(issue);
	}
	return { message };
};
var en_default = errorMap;

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/errors.js
let overrideErrorMap = en_default;
function getErrorMap() {
	return overrideErrorMap;
}

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/helpers/parseUtil.js
const makeIssue = (params) => {
	const { data, path, errorMaps, issueData } = params;
	const fullPath = [...path, ...issueData.path || []];
	const fullIssue = {
		...issueData,
		path: fullPath
	};
	if (issueData.message !== void 0) return {
		...issueData,
		path: fullPath,
		message: issueData.message
	};
	let errorMessage = "";
	const maps = errorMaps.filter((m) => !!m).slice().reverse();
	for (const map of maps) errorMessage = map(fullIssue, {
		data,
		defaultError: errorMessage
	}).message;
	return {
		...issueData,
		path: fullPath,
		message: errorMessage
	};
};
function addIssueToContext(ctx, issueData) {
	const overrideMap = getErrorMap();
	const issue = makeIssue({
		issueData,
		data: ctx.data,
		path: ctx.path,
		errorMaps: [
			ctx.common.contextualErrorMap,
			ctx.schemaErrorMap,
			overrideMap,
			overrideMap === en_default ? void 0 : en_default
		].filter((x) => !!x)
	});
	ctx.common.issues.push(issue);
}
var ParseStatus = class ParseStatus {
	constructor() {
		this.value = "valid";
	}
	dirty() {
		if (this.value === "valid") this.value = "dirty";
	}
	abort() {
		if (this.value !== "aborted") this.value = "aborted";
	}
	static mergeArray(status, results) {
		const arrayValue = [];
		for (const s of results) {
			if (s.status === "aborted") return INVALID;
			if (s.status === "dirty") status.dirty();
			arrayValue.push(s.value);
		}
		return {
			status: status.value,
			value: arrayValue
		};
	}
	static async mergeObjectAsync(status, pairs) {
		const syncPairs = [];
		for (const pair of pairs) {
			const key = await pair.key;
			const value = await pair.value;
			syncPairs.push({
				key,
				value
			});
		}
		return ParseStatus.mergeObjectSync(status, syncPairs);
	}
	static mergeObjectSync(status, pairs) {
		const finalObject = {};
		for (const pair of pairs) {
			const { key, value } = pair;
			if (key.status === "aborted") return INVALID;
			if (value.status === "aborted") return INVALID;
			if (key.status === "dirty") status.dirty();
			if (value.status === "dirty") status.dirty();
			if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) finalObject[key.value] = value.value;
		}
		return {
			status: status.value,
			value: finalObject
		};
	}
};
const INVALID = Object.freeze({ status: "aborted" });
const DIRTY = (value) => ({
	status: "dirty",
	value
});
const OK = (value) => ({
	status: "valid",
	value
});
const isAborted = (x) => x.status === "aborted";
const isDirty = (x) => x.status === "dirty";
const isValid = (x) => x.status === "valid";
const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/helpers/errorUtil.js
var errorUtil;
(function(errorUtil$1) {
	errorUtil$1.errToObj = (message) => typeof message === "string" ? { message } : message || {};
	errorUtil$1.toString = (message) => typeof message === "string" ? message : message?.message;
})(errorUtil || (errorUtil = {}));

//#endregion
//#region node_modules/.pnpm/zod@3.25.57/node_modules/zod/dist/esm/v3/types.js
var ParseInputLazyPath = class {
	constructor(parent, value, path, key) {
		this._cachedPath = [];
		this.parent = parent;
		this.data = value;
		this._path = path;
		this._key = key;
	}
	get path() {
		if (!this._cachedPath.length) if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key);
		else this._cachedPath.push(...this._path, this._key);
		return this._cachedPath;
	}
};
const handleResult = (ctx, result) => {
	if (isValid(result)) return {
		success: true,
		data: result.value
	};
	else {
		if (!ctx.common.issues.length) throw new Error("Validation failed but no issues detected.");
		return {
			success: false,
			get error() {
				if (this._error) return this._error;
				const error = new ZodError(ctx.common.issues);
				this._error = error;
				return this._error;
			}
		};
	}
};
function processCreateParams(params) {
	if (!params) return {};
	const { errorMap: errorMap$1, invalid_type_error, required_error, description } = params;
	if (errorMap$1 && (invalid_type_error || required_error)) throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
	if (errorMap$1) return {
		errorMap: errorMap$1,
		description
	};
	const customMap = (iss, ctx) => {
		const { message } = params;
		if (iss.code === "invalid_enum_value") return { message: message ?? ctx.defaultError };
		if (typeof ctx.data === "undefined") return { message: message ?? required_error ?? ctx.defaultError };
		if (iss.code !== "invalid_type") return { message: ctx.defaultError };
		return { message: message ?? invalid_type_error ?? ctx.defaultError };
	};
	return {
		errorMap: customMap,
		description
	};
}
var ZodType = class {
	get description() {
		return this._def.description;
	}
	_getType(input) {
		return getParsedType(input.data);
	}
	_getOrReturnCtx(input, ctx) {
		return ctx || {
			common: input.parent.common,
			data: input.data,
			parsedType: getParsedType(input.data),
			schemaErrorMap: this._def.errorMap,
			path: input.path,
			parent: input.parent
		};
	}
	_processInputParams(input) {
		return {
			status: new ParseStatus(),
			ctx: {
				common: input.parent.common,
				data: input.data,
				parsedType: getParsedType(input.data),
				schemaErrorMap: this._def.errorMap,
				path: input.path,
				parent: input.parent
			}
		};
	}
	_parseSync(input) {
		const result = this._parse(input);
		if (isAsync(result)) throw new Error("Synchronous parse encountered promise.");
		return result;
	}
	_parseAsync(input) {
		const result = this._parse(input);
		return Promise.resolve(result);
	}
	parse(data, params) {
		const result = this.safeParse(data, params);
		if (result.success) return result.data;
		throw result.error;
	}
	safeParse(data, params) {
		const ctx = {
			common: {
				issues: [],
				async: params?.async ?? false,
				contextualErrorMap: params?.errorMap
			},
			path: params?.path || [],
			schemaErrorMap: this._def.errorMap,
			parent: null,
			data,
			parsedType: getParsedType(data)
		};
		const result = this._parseSync({
			data,
			path: ctx.path,
			parent: ctx
		});
		return handleResult(ctx, result);
	}
	"~validate"(data) {
		const ctx = {
			common: {
				issues: [],
				async: !!this["~standard"].async
			},
			path: [],
			schemaErrorMap: this._def.errorMap,
			parent: null,
			data,
			parsedType: getParsedType(data)
		};
		if (!this["~standard"].async) try {
			const result = this._parseSync({
				data,
				path: [],
				parent: ctx
			});
			return isValid(result) ? { value: result.value } : { issues: ctx.common.issues };
		} catch (err) {
			if (err?.message?.toLowerCase()?.includes("encountered")) this["~standard"].async = true;
			ctx.common = {
				issues: [],
				async: true
			};
		}
		return this._parseAsync({
			data,
			path: [],
			parent: ctx
		}).then((result) => isValid(result) ? { value: result.value } : { issues: ctx.common.issues });
	}
	async parseAsync(data, params) {
		const result = await this.safeParseAsync(data, params);
		if (result.success) return result.data;
		throw result.error;
	}
	async safeParseAsync(data, params) {
		const ctx = {
			common: {
				issues: [],
				contextualErrorMap: params?.errorMap,
				async: true
			},
			path: params?.path || [],
			schemaErrorMap: this._def.errorMap,
			parent: null,
			data,
			parsedType: getParsedType(data)
		};
		const maybeAsyncResult = this._parse({
			data,
			path: ctx.path,
			parent: ctx
		});
		const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
		return handleResult(ctx, result);
	}
	refine(check, message) {
		const getIssueProperties = (val) => {
			if (typeof message === "string" || typeof message === "undefined") return { message };
			else if (typeof message === "function") return message(val);
			else return message;
		};
		return this._refinement((val, ctx) => {
			const result = check(val);
			const setError = () => ctx.addIssue({
				code: ZodIssueCode.custom,
				...getIssueProperties(val)
			});
			if (typeof Promise !== "undefined" && result instanceof Promise) return result.then((data) => {
				if (!data) {
					setError();
					return false;
				} else return true;
			});
			if (!result) {
				setError();
				return false;
			} else return true;
		});
	}
	refinement(check, refinementData) {
		return this._refinement((val, ctx) => {
			if (!check(val)) {
				ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
				return false;
			} else return true;
		});
	}
	_refinement(refinement) {
		return new ZodEffects({
			schema: this,
			typeName: ZodFirstPartyTypeKind.ZodEffects,
			effect: {
				type: "refinement",
				refinement
			}
		});
	}
	superRefine(refinement) {
		return this._refinement(refinement);
	}
	constructor(def) {
		/** Alias of safeParseAsync */
		this.spa = this.safeParseAsync;
		this._def = def;
		this.parse = this.parse.bind(this);
		this.safeParse = this.safeParse.bind(this);
		this.parseAsync = this.parseAsync.bind(this);
		this.safeParseAsync = this.safeParseAsync.bind(this);
		this.spa = this.spa.bind(this);
		this.refine = this.refine.bind(this);
		this.refinement = this.refinement.bind(this);
		this.superRefine = this.superRefine.bind(this);
		this.optional = this.optional.bind(this);
		this.nullable = this.nullable.bind(this);
		this.nullish = this.nullish.bind(this);
		this.array = this.array.bind(this);
		this.promise = this.promise.bind(this);
		this.or = this.or.bind(this);
		this.and = this.and.bind(this);
		this.transform = this.transform.bind(this);
		this.brand = this.brand.bind(this);
		this.default = this.default.bind(this);
		this.catch = this.catch.bind(this);
		this.describe = this.describe.bind(this);
		this.pipe = this.pipe.bind(this);
		this.readonly = this.readonly.bind(this);
		this.isNullable = this.isNullable.bind(this);
		this.isOptional = this.isOptional.bind(this);
		this["~standard"] = {
			version: 1,
			vendor: "zod",
			validate: (data) => this["~validate"](data)
		};
	}
	optional() {
		return ZodOptional.create(this, this._def);
	}
	nullable() {
		return ZodNullable.create(this, this._def);
	}
	nullish() {
		return this.nullable().optional();
	}
	array() {
		return ZodArray.create(this);
	}
	promise() {
		return ZodPromise.create(this, this._def);
	}
	or(option) {
		return ZodUnion.create([this, option], this._def);
	}
	and(incoming) {
		return ZodIntersection.create(this, incoming, this._def);
	}
	transform(transform) {
		return new ZodEffects({
			...processCreateParams(this._def),
			schema: this,
			typeName: ZodFirstPartyTypeKind.ZodEffects,
			effect: {
				type: "transform",
				transform
			}
		});
	}
	default(def) {
		const defaultValueFunc = typeof def === "function" ? def : () => def;
		return new ZodDefault({
			...processCreateParams(this._def),
			innerType: this,
			defaultValue: defaultValueFunc,
			typeName: ZodFirstPartyTypeKind.ZodDefault
		});
	}
	brand() {
		return new ZodBranded({
			typeName: ZodFirstPartyTypeKind.ZodBranded,
			type: this,
			...processCreateParams(this._def)
		});
	}
	catch(def) {
		const catchValueFunc = typeof def === "function" ? def : () => def;
		return new ZodCatch({
			...processCreateParams(this._def),
			innerType: this,
			catchValue: catchValueFunc,
			typeName: ZodFirstPartyTypeKind.ZodCatch
		});
	}
	describe(description) {
		const This = this.constructor;
		return new This({
			...this._def,
			description
		});
	}
	pipe(target) {
		return ZodPipeline.create(this, target);
	}
	readonly() {
		return ZodReadonly.create(this);
	}
	isOptional() {
		return this.safeParse(void 0).success;
	}
	isNullable() {
		return this.safeParse(null).success;
	}
};
const cuidRegex = /^c[^\s-]{8,}$/i;
const cuid2Regex = /^[0-9a-z]+$/;
const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
const uuidRegex = /^[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}$/i;
const nanoidRegex = /^[a-z0-9_-]{21}$/i;
const jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
const durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
let emojiRegex$1;
const ipv4Regex = /^(?:(?: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])$/;
const ipv4CidrRegex = /^(?:(?: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])$/;
const ipv6Regex = /^(([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]))$/;
const ipv6CidrRegex = /^(([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])$/;
const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
const base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
const dateRegex = new RegExp(`^${dateRegexSource}$`);
function timeRegexSource(args) {
	let secondsRegexSource = `[0-5]\\d`;
	if (args.precision) secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
	else if (args.precision == null) secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
	const secondsQuantifier = args.precision ? "+" : "?";
	return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex(args) {
	return new RegExp(`^${timeRegexSource(args)}$`);
}
function datetimeRegex(args) {
	let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
	const opts = [];
	opts.push(args.local ? `Z?` : `Z`);
	if (args.offset) opts.push(`([+-]\\d{2}:?\\d{2})`);
	regex = `${regex}(${opts.join("|")})`;
	return new RegExp(`^${regex}$`);
}
function isValidIP(ip, version) {
	if ((version === "v4" || !version) && ipv4Regex.test(ip)) return true;
	if ((version === "v6" || !version) && ipv6Regex.test(ip)) return true;
	return false;
}
function isValidJWT(jwt, alg) {
	if (!jwtRegex.test(jwt)) return false;
	try {
		const [header] = jwt.split(".");
		const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
		const decoded = JSON.parse(atob(base64));
		if (typeof decoded !== "object" || decoded === null) return false;
		if ("typ" in decoded && decoded?.typ !== "JWT") return false;
		if (!decoded.alg) return false;
		if (alg && decoded.alg !== alg) return false;
		return true;
	} catch {
		return false;
	}
}
function isValidCidr(ip, version) {
	if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) return true;
	if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) return true;
	return false;
}
var ZodString = class ZodString extends ZodType {
	_parse(input) {
		if (this._def.coerce) input.data = String(input.data);
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.string) {
			const ctx$1 = this._getOrReturnCtx(input);
			addIssueToContext(ctx$1, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.string,
				received: ctx$1.parsedType
			});
			return INVALID;
		}
		const status = new ParseStatus();
		let ctx = void 0;
		for (const check of this._def.checks) if (check.kind === "min") {
			if (input.data.length < check.value) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					minimum: check.value,
					type: "string",
					inclusive: true,
					exact: false,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "max") {
			if (input.data.length > check.value) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					maximum: check.value,
					type: "string",
					inclusive: true,
					exact: false,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "length") {
			const tooBig = input.data.length > check.value;
			const tooSmall = input.data.length < check.value;
			if (tooBig || tooSmall) {
				ctx = this._getOrReturnCtx(input, ctx);
				if (tooBig) addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					maximum: check.value,
					type: "string",
					inclusive: true,
					exact: true,
					message: check.message
				});
				else if (tooSmall) addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					minimum: check.value,
					type: "string",
					inclusive: true,
					exact: true,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "email") {
			if (!emailRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "email",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "emoji") {
			if (!emojiRegex$1) emojiRegex$1 = new RegExp(_emojiRegex, "u");
			if (!emojiRegex$1.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "emoji",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "uuid") {
			if (!uuidRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "uuid",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "nanoid") {
			if (!nanoidRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "nanoid",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "cuid") {
			if (!cuidRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "cuid",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "cuid2") {
			if (!cuid2Regex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "cuid2",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "ulid") {
			if (!ulidRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "ulid",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "url") try {
			new URL(input.data);
		} catch {
			ctx = this._getOrReturnCtx(input, ctx);
			addIssueToContext(ctx, {
				validation: "url",
				code: ZodIssueCode.invalid_string,
				message: check.message
			});
			status.dirty();
		}
		else if (check.kind === "regex") {
			check.regex.lastIndex = 0;
			const testResult = check.regex.test(input.data);
			if (!testResult) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "regex",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "trim") input.data = input.data.trim();
		else if (check.kind === "includes") {
			if (!input.data.includes(check.value, check.position)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_string,
					validation: {
						includes: check.value,
						position: check.position
					},
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "toLowerCase") input.data = input.data.toLowerCase();
		else if (check.kind === "toUpperCase") input.data = input.data.toUpperCase();
		else if (check.kind === "startsWith") {
			if (!input.data.startsWith(check.value)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_string,
					validation: { startsWith: check.value },
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "endsWith") {
			if (!input.data.endsWith(check.value)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_string,
					validation: { endsWith: check.value },
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "datetime") {
			const regex = datetimeRegex(check);
			if (!regex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_string,
					validation: "datetime",
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "date") {
			const regex = dateRegex;
			if (!regex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_string,
					validation: "date",
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "time") {
			const regex = timeRegex(check);
			if (!regex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_string,
					validation: "time",
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "duration") {
			if (!durationRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "duration",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "ip") {
			if (!isValidIP(input.data, check.version)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "ip",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "jwt") {
			if (!isValidJWT(input.data, check.alg)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "jwt",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "cidr") {
			if (!isValidCidr(input.data, check.version)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "cidr",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "base64") {
			if (!base64Regex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "base64",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "base64url") {
			if (!base64urlRegex.test(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					validation: "base64url",
					code: ZodIssueCode.invalid_string,
					message: check.message
				});
				status.dirty();
			}
		} else util.assertNever(check);
		return {
			status: status.value,
			value: input.data
		};
	}
	_regex(regex, validation, message) {
		return this.refinement((data) => regex.test(data), {
			validation,
			code: ZodIssueCode.invalid_string,
			...errorUtil.errToObj(message)
		});
	}
	_addCheck(check) {
		return new ZodString({
			...this._def,
			checks: [...this._def.checks, check]
		});
	}
	email(message) {
		return this._addCheck({
			kind: "email",
			...errorUtil.errToObj(message)
		});
	}
	url(message) {
		return this._addCheck({
			kind: "url",
			...errorUtil.errToObj(message)
		});
	}
	emoji(message) {
		return this._addCheck({
			kind: "emoji",
			...errorUtil.errToObj(message)
		});
	}
	uuid(message) {
		return this._addCheck({
			kind: "uuid",
			...errorUtil.errToObj(message)
		});
	}
	nanoid(message) {
		return this._addCheck({
			kind: "nanoid",
			...errorUtil.errToObj(message)
		});
	}
	cuid(message) {
		return this._addCheck({
			kind: "cuid",
			...errorUtil.errToObj(message)
		});
	}
	cuid2(message) {
		return this._addCheck({
			kind: "cuid2",
			...errorUtil.errToObj(message)
		});
	}
	ulid(message) {
		return this._addCheck({
			kind: "ulid",
			...errorUtil.errToObj(message)
		});
	}
	base64(message) {
		return this._addCheck({
			kind: "base64",
			...errorUtil.errToObj(message)
		});
	}
	base64url(message) {
		return this._addCheck({
			kind: "base64url",
			...errorUtil.errToObj(message)
		});
	}
	jwt(options) {
		return this._addCheck({
			kind: "jwt",
			...errorUtil.errToObj(options)
		});
	}
	ip(options) {
		return this._addCheck({
			kind: "ip",
			...errorUtil.errToObj(options)
		});
	}
	cidr(options) {
		return this._addCheck({
			kind: "cidr",
			...errorUtil.errToObj(options)
		});
	}
	datetime(options) {
		if (typeof options === "string") return this._addCheck({
			kind: "datetime",
			precision: null,
			offset: false,
			local: false,
			message: options
		});
		return this._addCheck({
			kind: "datetime",
			precision: typeof options?.precision === "undefined" ? null : options?.precision,
			offset: options?.offset ?? false,
			local: options?.local ?? false,
			...errorUtil.errToObj(options?.message)
		});
	}
	date(message) {
		return this._addCheck({
			kind: "date",
			message
		});
	}
	time(options) {
		if (typeof options === "string") return this._addCheck({
			kind: "time",
			precision: null,
			message: options
		});
		return this._addCheck({
			kind: "time",
			precision: typeof options?.precision === "undefined" ? null : options?.precision,
			...errorUtil.errToObj(options?.message)
		});
	}
	duration(message) {
		return this._addCheck({
			kind: "duration",
			...errorUtil.errToObj(message)
		});
	}
	regex(regex, message) {
		return this._addCheck({
			kind: "regex",
			regex,
			...errorUtil.errToObj(message)
		});
	}
	includes(value, options) {
		return this._addCheck({
			kind: "includes",
			value,
			position: options?.position,
			...errorUtil.errToObj(options?.message)
		});
	}
	startsWith(value, message) {
		return this._addCheck({
			kind: "startsWith",
			value,
			...errorUtil.errToObj(message)
		});
	}
	endsWith(value, message) {
		return this._addCheck({
			kind: "endsWith",
			value,
			...errorUtil.errToObj(message)
		});
	}
	min(minLength, message) {
		return this._addCheck({
			kind: "min",
			value: minLength,
			...errorUtil.errToObj(message)
		});
	}
	max(maxLength, message) {
		return this._addCheck({
			kind: "max",
			value: maxLength,
			...errorUtil.errToObj(message)
		});
	}
	length(len, message) {
		return this._addCheck({
			kind: "length",
			value: len,
			...errorUtil.errToObj(message)
		});
	}
	/**
	* Equivalent to `.min(1)`
	*/
	nonempty(message) {
		return this.min(1, errorUtil.errToObj(message));
	}
	trim() {
		return new ZodString({
			...this._def,
			checks: [...this._def.checks, { kind: "trim" }]
		});
	}
	toLowerCase() {
		return new ZodString({
			...this._def,
			checks: [...this._def.checks, { kind: "toLowerCase" }]
		});
	}
	toUpperCase() {
		return new ZodString({
			...this._def,
			checks: [...this._def.checks, { kind: "toUpperCase" }]
		});
	}
	get isDatetime() {
		return !!this._def.checks.find((ch) => ch.kind === "datetime");
	}
	get isDate() {
		return !!this._def.checks.find((ch) => ch.kind === "date");
	}
	get isTime() {
		return !!this._def.checks.find((ch) => ch.kind === "time");
	}
	get isDuration() {
		return !!this._def.checks.find((ch) => ch.kind === "duration");
	}
	get isEmail() {
		return !!this._def.checks.find((ch) => ch.kind === "email");
	}
	get isURL() {
		return !!this._def.checks.find((ch) => ch.kind === "url");
	}
	get isEmoji() {
		return !!this._def.checks.find((ch) => ch.kind === "emoji");
	}
	get isUUID() {
		return !!this._def.checks.find((ch) => ch.kind === "uuid");
	}
	get isNANOID() {
		return !!this._def.checks.find((ch) => ch.kind === "nanoid");
	}
	get isCUID() {
		return !!this._def.checks.find((ch) => ch.kind === "cuid");
	}
	get isCUID2() {
		return !!this._def.checks.find((ch) => ch.kind === "cuid2");
	}
	get isULID() {
		return !!this._def.checks.find((ch) => ch.kind === "ulid");
	}
	get isIP() {
		return !!this._def.checks.find((ch) => ch.kind === "ip");
	}
	get isCIDR() {
		return !!this._def.checks.find((ch) => ch.kind === "cidr");
	}
	get isBase64() {
		return !!this._def.checks.find((ch) => ch.kind === "base64");
	}
	get isBase64url() {
		return !!this._def.checks.find((ch) => ch.kind === "base64url");
	}
	get minLength() {
		let min = null;
		for (const ch of this._def.checks) if (ch.kind === "min") {
			if (min === null || ch.value > min) min = ch.value;
		}
		return min;
	}
	get maxLength() {
		let max = null;
		for (const ch of this._def.checks) if (ch.kind === "max") {
			if (max === null || ch.value < max) max = ch.value;
		}
		return max;
	}
};
ZodString.create = (params) => {
	return new ZodString({
		checks: [],
		typeName: ZodFirstPartyTypeKind.ZodString,
		coerce: params?.coerce ?? false,
		...processCreateParams(params)
	});
};
function floatSafeRemainder(val, step) {
	const valDecCount = (val.toString().split(".")[1] || "").length;
	const stepDecCount = (step.toString().split(".")[1] || "").length;
	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
	const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
	const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
	return valInt % stepInt / 10 ** decCount;
}
var ZodNumber = class ZodNumber extends ZodType {
	constructor() {
		super(...arguments);
		this.min = this.gte;
		this.max = this.lte;
		this.step = this.multipleOf;
	}
	_parse(input) {
		if (this._def.coerce) input.data = Number(input.data);
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.number) {
			const ctx$1 = this._getOrReturnCtx(input);
			addIssueToContext(ctx$1, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.number,
				received: ctx$1.parsedType
			});
			return INVALID;
		}
		let ctx = void 0;
		const status = new ParseStatus();
		for (const check of this._def.checks) if (check.kind === "int") {
			if (!util.isInteger(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.invalid_type,
					expected: "integer",
					received: "float",
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "min") {
			const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
			if (tooSmall) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					minimum: check.value,
					type: "number",
					inclusive: check.inclusive,
					exact: false,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "max") {
			const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
			if (tooBig) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					maximum: check.value,
					type: "number",
					inclusive: check.inclusive,
					exact: false,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "multipleOf") {
			if (floatSafeRemainder(input.data, check.value) !== 0) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.not_multiple_of,
					multipleOf: check.value,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "finite") {
			if (!Number.isFinite(input.data)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.not_finite,
					message: check.message
				});
				status.dirty();
			}
		} else util.assertNever(check);
		return {
			status: status.value,
			value: input.data
		};
	}
	gte(value, message) {
		return this.setLimit("min", value, true, errorUtil.toString(message));
	}
	gt(value, message) {
		return this.setLimit("min", value, false, errorUtil.toString(message));
	}
	lte(value, message) {
		return this.setLimit("max", value, true, errorUtil.toString(message));
	}
	lt(value, message) {
		return this.setLimit("max", value, false, errorUtil.toString(message));
	}
	setLimit(kind, value, inclusive, message) {
		return new ZodNumber({
			...this._def,
			checks: [...this._def.checks, {
				kind,
				value,
				inclusive,
				message: errorUtil.toString(message)
			}]
		});
	}
	_addCheck(check) {
		return new ZodNumber({
			...this._def,
			checks: [...this._def.checks, check]
		});
	}
	int(message) {
		return this._addCheck({
			kind: "int",
			message: errorUtil.toString(message)
		});
	}
	positive(message) {
		return this._addCheck({
			kind: "min",
			value: 0,
			inclusive: false,
			message: errorUtil.toString(message)
		});
	}
	negative(message) {
		return this._addCheck({
			kind: "max",
			value: 0,
			inclusive: false,
			message: errorUtil.toString(message)
		});
	}
	nonpositive(message) {
		return this._addCheck({
			kind: "max",
			value: 0,
			inclusive: true,
			message: errorUtil.toString(message)
		});
	}
	nonnegative(message) {
		return this._addCheck({
			kind: "min",
			value: 0,
			inclusive: true,
			message: errorUtil.toString(message)
		});
	}
	multipleOf(value, message) {
		return this._addCheck({
			kind: "multipleOf",
			value,
			message: errorUtil.toString(message)
		});
	}
	finite(message) {
		return this._addCheck({
			kind: "finite",
			message: errorUtil.toString(message)
		});
	}
	safe(message) {
		return this._addCheck({
			kind: "min",
			inclusive: true,
			value: Number.MIN_SAFE_INTEGER,
			message: errorUtil.toString(message)
		})._addCheck({
			kind: "max",
			inclusive: true,
			value: Number.MAX_SAFE_INTEGER,
			message: errorUtil.toString(message)
		});
	}
	get minValue() {
		let min = null;
		for (const ch of this._def.checks) if (ch.kind === "min") {
			if (min === null || ch.value > min) min = ch.value;
		}
		return min;
	}
	get maxValue() {
		let max = null;
		for (const ch of this._def.checks) if (ch.kind === "max") {
			if (max === null || ch.value < max) max = ch.value;
		}
		return max;
	}
	get isInt() {
		return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
	}
	get isFinite() {
		let max = null;
		let min = null;
		for (const ch of this._def.checks) if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") return true;
		else if (ch.kind === "min") {
			if (min === null || ch.value > min) min = ch.value;
		} else if (ch.kind === "max") {
			if (max === null || ch.value < max) max = ch.value;
		}
		return Number.isFinite(min) && Number.isFinite(max);
	}
};
ZodNumber.create = (params) => {
	return new ZodNumber({
		checks: [],
		typeName: ZodFirstPartyTypeKind.ZodNumber,
		coerce: params?.coerce || false,
		...processCreateParams(params)
	});
};
var ZodBigInt = class ZodBigInt extends ZodType {
	constructor() {
		super(...arguments);
		this.min = this.gte;
		this.max = this.lte;
	}
	_parse(input) {
		if (this._def.coerce) try {
			input.data = BigInt(input.data);
		} catch {
			return this._getInvalidInput(input);
		}
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.bigint) return this._getInvalidInput(input);
		let ctx = void 0;
		const status = new ParseStatus();
		for (const check of this._def.checks) if (check.kind === "min") {
			const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
			if (tooSmall) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					type: "bigint",
					minimum: check.value,
					inclusive: check.inclusive,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "max") {
			const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
			if (tooBig) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					type: "bigint",
					maximum: check.value,
					inclusive: check.inclusive,
					message: check.message
				});
				status.dirty();
			}
		} else if (check.kind === "multipleOf") {
			if (input.data % check.value !== BigInt(0)) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.not_multiple_of,
					multipleOf: check.value,
					message: check.message
				});
				status.dirty();
			}
		} else util.assertNever(check);
		return {
			status: status.value,
			value: input.data
		};
	}
	_getInvalidInput(input) {
		const ctx = this._getOrReturnCtx(input);
		addIssueToContext(ctx, {
			code: ZodIssueCode.invalid_type,
			expected: ZodParsedType.bigint,
			received: ctx.parsedType
		});
		return INVALID;
	}
	gte(value, message) {
		return this.setLimit("min", value, true, errorUtil.toString(message));
	}
	gt(value, message) {
		return this.setLimit("min", value, false, errorUtil.toString(message));
	}
	lte(value, message) {
		return this.setLimit("max", value, true, errorUtil.toString(message));
	}
	lt(value, message) {
		return this.setLimit("max", value, false, errorUtil.toString(message));
	}
	setLimit(kind, value, inclusive, message) {
		return new ZodBigInt({
			...this._def,
			checks: [...this._def.checks, {
				kind,
				value,
				inclusive,
				message: errorUtil.toString(message)
			}]
		});
	}
	_addCheck(check) {
		return new ZodBigInt({
			...this._def,
			checks: [...this._def.checks, check]
		});
	}
	positive(message) {
		return this._addCheck({
			kind: "min",
			value: BigInt(0),
			inclusive: false,
			message: errorUtil.toString(message)
		});
	}
	negative(message) {
		return this._addCheck({
			kind: "max",
			value: BigInt(0),
			inclusive: false,
			message: errorUtil.toString(message)
		});
	}
	nonpositive(message) {
		return this._addCheck({
			kind: "max",
			value: BigInt(0),
			inclusive: true,
			message: errorUtil.toString(message)
		});
	}
	nonnegative(message) {
		return this._addCheck({
			kind: "min",
			value: BigInt(0),
			inclusive: true,
			message: errorUtil.toString(message)
		});
	}
	multipleOf(value, message) {
		return this._addCheck({
			kind: "multipleOf",
			value,
			message: errorUtil.toString(message)
		});
	}
	get minValue() {
		let min = null;
		for (const ch of this._def.checks) if (ch.kind === "min") {
			if (min === null || ch.value > min) min = ch.value;
		}
		return min;
	}
	get maxValue() {
		let max = null;
		for (const ch of this._def.checks) if (ch.kind === "max") {
			if (max === null || ch.value < max) max = ch.value;
		}
		return max;
	}
};
ZodBigInt.create = (params) => {
	return new ZodBigInt({
		checks: [],
		typeName: ZodFirstPartyTypeKind.ZodBigInt,
		coerce: params?.coerce ?? false,
		...processCreateParams(params)
	});
};
var ZodBoolean = class extends ZodType {
	_parse(input) {
		if (this._def.coerce) input.data = Boolean(input.data);
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.boolean) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.boolean,
				received: ctx.parsedType
			});
			return INVALID;
		}
		return OK(input.data);
	}
};
ZodBoolean.create = (params) => {
	return new ZodBoolean({
		typeName: ZodFirstPartyTypeKind.ZodBoolean,
		coerce: params?.coerce || false,
		...processCreateParams(params)
	});
};
var ZodDate = class ZodDate extends ZodType {
	_parse(input) {
		if (this._def.coerce) input.data = new Date(input.data);
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.date) {
			const ctx$1 = this._getOrReturnCtx(input);
			addIssueToContext(ctx$1, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.date,
				received: ctx$1.parsedType
			});
			return INVALID;
		}
		if (Number.isNaN(input.data.getTime())) {
			const ctx$1 = this._getOrReturnCtx(input);
			addIssueToContext(ctx$1, { code: ZodIssueCode.invalid_date });
			return INVALID;
		}
		const status = new ParseStatus();
		let ctx = void 0;
		for (const check of this._def.checks) if (check.kind === "min") {
			if (input.data.getTime() < check.value) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					message: check.message,
					inclusive: true,
					exact: false,
					minimum: check.value,
					type: "date"
				});
				status.dirty();
			}
		} else if (check.kind === "max") {
			if (input.data.getTime() > check.value) {
				ctx = this._getOrReturnCtx(input, ctx);
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					message: check.message,
					inclusive: true,
					exact: false,
					maximum: check.value,
					type: "date"
				});
				status.dirty();
			}
		} else util.assertNever(check);
		return {
			status: status.value,
			value: new Date(input.data.getTime())
		};
	}
	_addCheck(check) {
		return new ZodDate({
			...this._def,
			checks: [...this._def.checks, check]
		});
	}
	min(minDate, message) {
		return this._addCheck({
			kind: "min",
			value: minDate.getTime(),
			message: errorUtil.toString(message)
		});
	}
	max(maxDate, message) {
		return this._addCheck({
			kind: "max",
			value: maxDate.getTime(),
			message: errorUtil.toString(message)
		});
	}
	get minDate() {
		let min = null;
		for (const ch of this._def.checks) if (ch.kind === "min") {
			if (min === null || ch.value > min) min = ch.value;
		}
		return min != null ? new Date(min) : null;
	}
	get maxDate() {
		let max = null;
		for (const ch of this._def.checks) if (ch.kind === "max") {
			if (max === null || ch.value < max) max = ch.value;
		}
		return max != null ? new Date(max) : null;
	}
};
ZodDate.create = (params) => {
	return new ZodDate({
		checks: [],
		coerce: params?.coerce || false,
		typeName: ZodFirstPartyTypeKind.ZodDate,
		...processCreateParams(params)
	});
};
var ZodSymbol = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.symbol) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.symbol,
				received: ctx.parsedType
			});
			return INVALID;
		}
		return OK(input.data);
	}
};
ZodSymbol.create = (params) => {
	return new ZodSymbol({
		typeName: ZodFirstPartyTypeKind.ZodSymbol,
		...processCreateParams(params)
	});
};
var ZodUndefined = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.undefined) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.undefined,
				received: ctx.parsedType
			});
			return INVALID;
		}
		return OK(input.data);
	}
};
ZodUndefined.create = (params) => {
	return new ZodUndefined({
		typeName: ZodFirstPartyTypeKind.ZodUndefined,
		...processCreateParams(params)
	});
};
var ZodNull = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.null) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.null,
				received: ctx.parsedType
			});
			return INVALID;
		}
		return OK(input.data);
	}
};
ZodNull.create = (params) => {
	return new ZodNull({
		typeName: ZodFirstPartyTypeKind.ZodNull,
		...processCreateParams(params)
	});
};
var ZodAny = class extends ZodType {
	constructor() {
		super(...arguments);
		this._any = true;
	}
	_parse(input) {
		return OK(input.data);
	}
};
ZodAny.create = (params) => {
	return new ZodAny({
		typeName: ZodFirstPartyTypeKind.ZodAny,
		...processCreateParams(params)
	});
};
var ZodUnknown = class extends ZodType {
	constructor() {
		super(...arguments);
		this._unknown = true;
	}
	_parse(input) {
		return OK(input.data);
	}
};
ZodUnknown.create = (params) => {
	return new ZodUnknown({
		typeName: ZodFirstPartyTypeKind.ZodUnknown,
		...processCreateParams(params)
	});
};
var ZodNever = class extends ZodType {
	_parse(input) {
		const ctx = this._getOrReturnCtx(input);
		addIssueToContext(ctx, {
			code: ZodIssueCode.invalid_type,
			expected: ZodParsedType.never,
			received: ctx.parsedType
		});
		return INVALID;
	}
};
ZodNever.create = (params) => {
	return new ZodNever({
		typeName: ZodFirstPartyTypeKind.ZodNever,
		...processCreateParams(params)
	});
};
var ZodVoid = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.undefined) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.void,
				received: ctx.parsedType
			});
			return INVALID;
		}
		return OK(input.data);
	}
};
ZodVoid.create = (params) => {
	return new ZodVoid({
		typeName: ZodFirstPartyTypeKind.ZodVoid,
		...processCreateParams(params)
	});
};
var ZodArray = class ZodArray extends ZodType {
	_parse(input) {
		const { ctx, status } = this._processInputParams(input);
		const def = this._def;
		if (ctx.parsedType !== ZodParsedType.array) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.array,
				received: ctx.parsedType
			});
			return INVALID;
		}
		if (def.exactLength !== null) {
			const tooBig = ctx.data.length > def.exactLength.value;
			const tooSmall = ctx.data.length < def.exactLength.value;
			if (tooBig || tooSmall) {
				addIssueToContext(ctx, {
					code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
					minimum: tooSmall ? def.exactLength.value : void 0,
					maximum: tooBig ? def.exactLength.value : void 0,
					type: "array",
					inclusive: true,
					exact: true,
					message: def.exactLength.message
				});
				status.dirty();
			}
		}
		if (def.minLength !== null) {
			if (ctx.data.length < def.minLength.value) {
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					minimum: def.minLength.value,
					type: "array",
					inclusive: true,
					exact: false,
					message: def.minLength.message
				});
				status.dirty();
			}
		}
		if (def.maxLength !== null) {
			if (ctx.data.length > def.maxLength.value) {
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					maximum: def.maxLength.value,
					type: "array",
					inclusive: true,
					exact: false,
					message: def.maxLength.message
				});
				status.dirty();
			}
		}
		if (ctx.common.async) return Promise.all([...ctx.data].map((item, i) => {
			return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
		})).then((result$1) => {
			return ParseStatus.mergeArray(status, result$1);
		});
		const result = [...ctx.data].map((item, i) => {
			return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
		});
		return ParseStatus.mergeArray(status, result);
	}
	get element() {
		return this._def.type;
	}
	min(minLength, message) {
		return new ZodArray({
			...this._def,
			minLength: {
				value: minLength,
				message: errorUtil.toString(message)
			}
		});
	}
	max(maxLength, message) {
		return new ZodArray({
			...this._def,
			maxLength: {
				value: maxLength,
				message: errorUtil.toString(message)
			}
		});
	}
	length(len, message) {
		return new ZodArray({
			...this._def,
			exactLength: {
				value: len,
				message: errorUtil.toString(message)
			}
		});
	}
	nonempty(message) {
		return this.min(1, message);
	}
};
ZodArray.create = (schema, params) => {
	return new ZodArray({
		type: schema,
		minLength: null,
		maxLength: null,
		exactLength: null,
		typeName: ZodFirstPartyTypeKind.ZodArray,
		...processCreateParams(params)
	});
};
function deepPartialify(schema) {
	if (schema instanceof ZodObject) {
		const newShape = {};
		for (const key in schema.shape) {
			const fieldSchema = schema.shape[key];
			newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
		}
		return new ZodObject({
			...schema._def,
			shape: () => newShape
		});
	} else if (schema instanceof ZodArray) return new ZodArray({
		...schema._def,
		type: deepPartialify(schema.element)
	});
	else if (schema instanceof ZodOptional) return ZodOptional.create(deepPartialify(schema.unwrap()));
	else if (schema instanceof ZodNullable) return ZodNullable.create(deepPartialify(schema.unwrap()));
	else if (schema instanceof ZodTuple) return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
	else return schema;
}
var ZodObject = class ZodObject extends ZodType {
	constructor() {
		super(...arguments);
		this._cached = null;
		/**
		* @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
		* If you want to pass through unknown properties, use `.passthrough()` instead.
		*/
		this.nonstrict = this.passthrough;
		/**
		* @deprecated Use `.extend` instead
		*  */
		this.augment = this.extend;
	}
	_getCached() {
		if (this._cached !== null) return this._cached;
		const shape = this._def.shape();
		const keys = util.objectKeys(shape);
		this._cached = {
			shape,
			keys
		};
		return this._cached;
	}
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.object) {
			const ctx$1 = this._getOrReturnCtx(input);
			addIssueToContext(ctx$1, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.object,
				received: ctx$1.parsedType
			});
			return INVALID;
		}
		const { status, ctx } = this._processInputParams(input);
		const { shape, keys: shapeKeys } = this._getCached();
		const extraKeys = [];
		if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
			for (const key in ctx.data) if (!shapeKeys.includes(key)) extraKeys.push(key);
		}
		const pairs = [];
		for (const key of shapeKeys) {
			const keyValidator = shape[key];
			const value = ctx.data[key];
			pairs.push({
				key: {
					status: "valid",
					value: key
				},
				value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
				alwaysSet: key in ctx.data
			});
		}
		if (this._def.catchall instanceof ZodNever) {
			const unknownKeys = this._def.unknownKeys;
			if (unknownKeys === "passthrough") for (const key of extraKeys) pairs.push({
				key: {
					status: "valid",
					value: key
				},
				value: {
					status: "valid",
					value: ctx.data[key]
				}
			});
			else if (unknownKeys === "strict") {
				if (extraKeys.length > 0) {
					addIssueToContext(ctx, {
						code: ZodIssueCode.unrecognized_keys,
						keys: extraKeys
					});
					status.dirty();
				}
			} else if (unknownKeys === "strip") {} else throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
		} else {
			const catchall = this._def.catchall;
			for (const key of extraKeys) {
				const value = ctx.data[key];
				pairs.push({
					key: {
						status: "valid",
						value: key
					},
					value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
					alwaysSet: key in ctx.data
				});
			}
		}
		if (ctx.common.async) return Promise.resolve().then(async () => {
			const syncPairs = [];
			for (const pair of pairs) {
				const key = await pair.key;
				const value = await pair.value;
				syncPairs.push({
					key,
					value,
					alwaysSet: pair.alwaysSet
				});
			}
			return syncPairs;
		}).then((syncPairs) => {
			return ParseStatus.mergeObjectSync(status, syncPairs);
		});
		else return ParseStatus.mergeObjectSync(status, pairs);
	}
	get shape() {
		return this._def.shape();
	}
	strict(message) {
		errorUtil.errToObj;
		return new ZodObject({
			...this._def,
			unknownKeys: "strict",
			...message !== void 0 ? { errorMap: (issue, ctx) => {
				const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
				if (issue.code === "unrecognized_keys") return { message: errorUtil.errToObj(message).message ?? defaultError };
				return { message: defaultError };
			} } : {}
		});
	}
	strip() {
		return new ZodObject({
			...this._def,
			unknownKeys: "strip"
		});
	}
	passthrough() {
		return new ZodObject({
			...this._def,
			unknownKeys: "passthrough"
		});
	}
	extend(augmentation) {
		return new ZodObject({
			...this._def,
			shape: () => ({
				...this._def.shape(),
				...augmentation
			})
		});
	}
	/**
	* Prior to zod@1.0.12 there was a bug in the
	* inferred type of merged objects. Please
	* upgrade if you are experiencing issues.
	*/
	merge(merging) {
		const merged = new ZodObject({
			unknownKeys: merging._def.unknownKeys,
			catchall: merging._def.catchall,
			shape: () => ({
				...this._def.shape(),
				...merging._def.shape()
			}),
			typeName: ZodFirstPartyTypeKind.ZodObject
		});
		return merged;
	}
	setKey(key, schema) {
		return this.augment({ [key]: schema });
	}
	catchall(index) {
		return new ZodObject({
			...this._def,
			catchall: index
		});
	}
	pick(mask) {
		const shape = {};
		for (const key of util.objectKeys(mask)) if (mask[key] && this.shape[key]) shape[key] = this.shape[key];
		return new ZodObject({
			...this._def,
			shape: () => shape
		});
	}
	omit(mask) {
		const shape = {};
		for (const key of util.objectKeys(this.shape)) if (!mask[key]) shape[key] = this.shape[key];
		return new ZodObject({
			...this._def,
			shape: () => shape
		});
	}
	/**
	* @deprecated
	*/
	deepPartial() {
		return deepPartialify(this);
	}
	partial(mask) {
		const newShape = {};
		for (const key of util.objectKeys(this.shape)) {
			const fieldSchema = this.shape[key];
			if (mask && !mask[key]) newShape[key] = fieldSchema;
			else newShape[key] = fieldSchema.optional();
		}
		return new ZodObject({
			...this._def,
			shape: () => newShape
		});
	}
	required(mask) {
		const newShape = {};
		for (const key of util.objectKeys(this.shape)) if (mask && !mask[key]) newShape[key] = this.shape[key];
		else {
			const fieldSchema = this.shape[key];
			let newField = fieldSchema;
			while (newField instanceof ZodOptional) newField = newField._def.innerType;
			newShape[key] = newField;
		}
		return new ZodObject({
			...this._def,
			shape: () => newShape
		});
	}
	keyof() {
		return createZodEnum(util.objectKeys(this.shape));
	}
};
ZodObject.create = (shape, params) => {
	return new ZodObject({
		shape: () => shape,
		unknownKeys: "strip",
		catchall: ZodNever.create(),
		typeName: ZodFirstPartyTypeKind.ZodObject,
		...processCreateParams(params)
	});
};
ZodObject.strictCreate = (shape, params) => {
	return new ZodObject({
		shape: () => shape,
		unknownKeys: "strict",
		catchall: ZodNever.create(),
		typeName: ZodFirstPartyTypeKind.ZodObject,
		...processCreateParams(params)
	});
};
ZodObject.lazycreate = (shape, params) => {
	return new ZodObject({
		shape,
		unknownKeys: "strip",
		catchall: ZodNever.create(),
		typeName: ZodFirstPartyTypeKind.ZodObject,
		...processCreateParams(params)
	});
};
var ZodUnion = class extends ZodType {
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		const options = this._def.options;
		function handleResults(results) {
			for (const result of results) if (result.result.status === "valid") return result.result;
			for (const result of results) if (result.result.status === "dirty") {
				ctx.common.issues.push(...result.ctx.common.issues);
				return result.result;
			}
			const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_union,
				unionErrors
			});
			return INVALID;
		}
		if (ctx.common.async) return Promise.all(options.map(async (option) => {
			const childCtx = {
				...ctx,
				common: {
					...ctx.common,
					issues: []
				},
				parent: null
			};
			return {
				result: await option._parseAsync({
					data: ctx.data,
					path: ctx.path,
					parent: childCtx
				}),
				ctx: childCtx
			};
		})).then(handleResults);
		else {
			let dirty = void 0;
			const issues = [];
			for (const option of options) {
				const childCtx = {
					...ctx,
					common: {
						...ctx.common,
						issues: []
					},
					parent: null
				};
				const result = option._parseSync({
					data: ctx.data,
					path: ctx.path,
					parent: childCtx
				});
				if (result.status === "valid") return result;
				else if (result.status === "dirty" && !dirty) dirty = {
					result,
					ctx: childCtx
				};
				if (childCtx.common.issues.length) issues.push(childCtx.common.issues);
			}
			if (dirty) {
				ctx.common.issues.push(...dirty.ctx.common.issues);
				return dirty.result;
			}
			const unionErrors = issues.map((issues$1) => new ZodError(issues$1));
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_union,
				unionErrors
			});
			return INVALID;
		}
	}
	get options() {
		return this._def.options;
	}
};
ZodUnion.create = (types, params) => {
	return new ZodUnion({
		options: types,
		typeName: ZodFirstPartyTypeKind.ZodUnion,
		...processCreateParams(params)
	});
};
const getDiscriminator = (type) => {
	if (type instanceof ZodLazy) return getDiscriminator(type.schema);
	else if (type instanceof ZodEffects) return getDiscriminator(type.innerType());
	else if (type instanceof ZodLiteral) return [type.value];
	else if (type instanceof ZodEnum) return type.options;
	else if (type instanceof ZodNativeEnum) return util.objectValues(type.enum);
	else if (type instanceof ZodDefault) return getDiscriminator(type._def.innerType);
	else if (type instanceof ZodUndefined) return [void 0];
	else if (type instanceof ZodNull) return [null];
	else if (type instanceof ZodOptional) return [void 0, ...getDiscriminator(type.unwrap())];
	else if (type instanceof ZodNullable) return [null, ...getDiscriminator(type.unwrap())];
	else if (type instanceof ZodBranded) return getDiscriminator(type.unwrap());
	else if (type instanceof ZodReadonly) return getDiscriminator(type.unwrap());
	else if (type instanceof ZodCatch) return getDiscriminator(type._def.innerType);
	else return [];
};
var ZodDiscriminatedUnion = class ZodDiscriminatedUnion extends ZodType {
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.object) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.object,
				received: ctx.parsedType
			});
			return INVALID;
		}
		const discriminator = this.discriminator;
		const discriminatorValue = ctx.data[discriminator];
		const option = this.optionsMap.get(discriminatorValue);
		if (!option) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_union_discriminator,
				options: Array.from(this.optionsMap.keys()),
				path: [discriminator]
			});
			return INVALID;
		}
		if (ctx.common.async) return option._parseAsync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		});
		else return option._parseSync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		});
	}
	get discriminator() {
		return this._def.discriminator;
	}
	get options() {
		return this._def.options;
	}
	get optionsMap() {
		return this._def.optionsMap;
	}
	/**
	* The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
	* However, it only allows a union of objects, all of which need to share a discriminator property. This property must
	* have a different value for each object in the union.
	* @param discriminator the name of the discriminator property
	* @param types an array of object schemas
	* @param params
	*/
	static create(discriminator, options, params) {
		const optionsMap = /* @__PURE__ */ new Map();
		for (const type of options) {
			const discriminatorValues = getDiscriminator(type.shape[discriminator]);
			if (!discriminatorValues.length) throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
			for (const value of discriminatorValues) {
				if (optionsMap.has(value)) throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
				optionsMap.set(value, type);
			}
		}
		return new ZodDiscriminatedUnion({
			typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
			discriminator,
			options,
			optionsMap,
			...processCreateParams(params)
		});
	}
};
function mergeValues(a, b) {
	const aType = getParsedType(a);
	const bType = getParsedType(b);
	if (a === b) return {
		valid: true,
		data: a
	};
	else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
		const bKeys = util.objectKeys(b);
		const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
		const newObj = {
			...a,
			...b
		};
		for (const key of sharedKeys) {
			const sharedValue = mergeValues(a[key], b[key]);
			if (!sharedValue.valid) return { valid: false };
			newObj[key] = sharedValue.data;
		}
		return {
			valid: true,
			data: newObj
		};
	} else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
		if (a.length !== b.length) return { valid: false };
		const newArray = [];
		for (let index = 0; index < a.length; index++) {
			const itemA = a[index];
			const itemB = b[index];
			const sharedValue = mergeValues(itemA, itemB);
			if (!sharedValue.valid) return { valid: false };
			newArray.push(sharedValue.data);
		}
		return {
			valid: true,
			data: newArray
		};
	} else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) return {
		valid: true,
		data: a
	};
	else return { valid: false };
}
var ZodIntersection = class extends ZodType {
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		const handleParsed = (parsedLeft, parsedRight) => {
			if (isAborted(parsedLeft) || isAborted(parsedRight)) return INVALID;
			const merged = mergeValues(parsedLeft.value, parsedRight.value);
			if (!merged.valid) {
				addIssueToContext(ctx, { code: ZodIssueCode.invalid_intersection_types });
				return INVALID;
			}
			if (isDirty(parsedLeft) || isDirty(parsedRight)) status.dirty();
			return {
				status: status.value,
				value: merged.data
			};
		};
		if (ctx.common.async) return Promise.all([this._def.left._parseAsync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		}), this._def.right._parseAsync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		})]).then(([left, right]) => handleParsed(left, right));
		else return handleParsed(this._def.left._parseSync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		}), this._def.right._parseSync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		}));
	}
};
ZodIntersection.create = (left, right, params) => {
	return new ZodIntersection({
		left,
		right,
		typeName: ZodFirstPartyTypeKind.ZodIntersection,
		...processCreateParams(params)
	});
};
var ZodTuple = class ZodTuple extends ZodType {
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.array) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.array,
				received: ctx.parsedType
			});
			return INVALID;
		}
		if (ctx.data.length < this._def.items.length) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.too_small,
				minimum: this._def.items.length,
				inclusive: true,
				exact: false,
				type: "array"
			});
			return INVALID;
		}
		const rest = this._def.rest;
		if (!rest && ctx.data.length > this._def.items.length) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.too_big,
				maximum: this._def.items.length,
				inclusive: true,
				exact: false,
				type: "array"
			});
			status.dirty();
		}
		const items = [...ctx.data].map((item, itemIndex) => {
			const schema = this._def.items[itemIndex] || this._def.rest;
			if (!schema) return null;
			return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
		}).filter((x) => !!x);
		if (ctx.common.async) return Promise.all(items).then((results) => {
			return ParseStatus.mergeArray(status, results);
		});
		else return ParseStatus.mergeArray(status, items);
	}
	get items() {
		return this._def.items;
	}
	rest(rest) {
		return new ZodTuple({
			...this._def,
			rest
		});
	}
};
ZodTuple.create = (schemas, params) => {
	if (!Array.isArray(schemas)) throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
	return new ZodTuple({
		items: schemas,
		typeName: ZodFirstPartyTypeKind.ZodTuple,
		rest: null,
		...processCreateParams(params)
	});
};
var ZodRecord = class ZodRecord extends ZodType {
	get keySchema() {
		return this._def.keyType;
	}
	get valueSchema() {
		return this._def.valueType;
	}
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.object) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.object,
				received: ctx.parsedType
			});
			return INVALID;
		}
		const pairs = [];
		const keyType = this._def.keyType;
		const valueType = this._def.valueType;
		for (const key in ctx.data) pairs.push({
			key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
			value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
			alwaysSet: key in ctx.data
		});
		if (ctx.common.async) return ParseStatus.mergeObjectAsync(status, pairs);
		else return ParseStatus.mergeObjectSync(status, pairs);
	}
	get element() {
		return this._def.valueType;
	}
	static create(first, second, third) {
		if (second instanceof ZodType) return new ZodRecord({
			keyType: first,
			valueType: second,
			typeName: ZodFirstPartyTypeKind.ZodRecord,
			...processCreateParams(third)
		});
		return new ZodRecord({
			keyType: ZodString.create(),
			valueType: first,
			typeName: ZodFirstPartyTypeKind.ZodRecord,
			...processCreateParams(second)
		});
	}
};
var ZodMap = class extends ZodType {
	get keySchema() {
		return this._def.keyType;
	}
	get valueSchema() {
		return this._def.valueType;
	}
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.map) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.map,
				received: ctx.parsedType
			});
			return INVALID;
		}
		const keyType = this._def.keyType;
		const valueType = this._def.valueType;
		const pairs = [...ctx.data.entries()].map(([key, value], index) => {
			return {
				key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
				value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
			};
		});
		if (ctx.common.async) {
			const finalMap = /* @__PURE__ */ new Map();
			return Promise.resolve().then(async () => {
				for (const pair of pairs) {
					const key = await pair.key;
					const value = await pair.value;
					if (key.status === "aborted" || value.status === "aborted") return INVALID;
					if (key.status === "dirty" || value.status === "dirty") status.dirty();
					finalMap.set(key.value, value.value);
				}
				return {
					status: status.value,
					value: finalMap
				};
			});
		} else {
			const finalMap = /* @__PURE__ */ new Map();
			for (const pair of pairs) {
				const key = pair.key;
				const value = pair.value;
				if (key.status === "aborted" || value.status === "aborted") return INVALID;
				if (key.status === "dirty" || value.status === "dirty") status.dirty();
				finalMap.set(key.value, value.value);
			}
			return {
				status: status.value,
				value: finalMap
			};
		}
	}
};
ZodMap.create = (keyType, valueType, params) => {
	return new ZodMap({
		valueType,
		keyType,
		typeName: ZodFirstPartyTypeKind.ZodMap,
		...processCreateParams(params)
	});
};
var ZodSet = class ZodSet extends ZodType {
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.set) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.set,
				received: ctx.parsedType
			});
			return INVALID;
		}
		const def = this._def;
		if (def.minSize !== null) {
			if (ctx.data.size < def.minSize.value) {
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_small,
					minimum: def.minSize.value,
					type: "set",
					inclusive: true,
					exact: false,
					message: def.minSize.message
				});
				status.dirty();
			}
		}
		if (def.maxSize !== null) {
			if (ctx.data.size > def.maxSize.value) {
				addIssueToContext(ctx, {
					code: ZodIssueCode.too_big,
					maximum: def.maxSize.value,
					type: "set",
					inclusive: true,
					exact: false,
					message: def.maxSize.message
				});
				status.dirty();
			}
		}
		const valueType = this._def.valueType;
		function finalizeSet(elements$1) {
			const parsedSet = /* @__PURE__ */ new Set();
			for (const element of elements$1) {
				if (element.status === "aborted") return INVALID;
				if (element.status === "dirty") status.dirty();
				parsedSet.add(element.value);
			}
			return {
				status: status.value,
				value: parsedSet
			};
		}
		const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
		if (ctx.common.async) return Promise.all(elements).then((elements$1) => finalizeSet(elements$1));
		else return finalizeSet(elements);
	}
	min(minSize, message) {
		return new ZodSet({
			...this._def,
			minSize: {
				value: minSize,
				message: errorUtil.toString(message)
			}
		});
	}
	max(maxSize, message) {
		return new ZodSet({
			...this._def,
			maxSize: {
				value: maxSize,
				message: errorUtil.toString(message)
			}
		});
	}
	size(size, message) {
		return this.min(size, message).max(size, message);
	}
	nonempty(message) {
		return this.min(1, message);
	}
};
ZodSet.create = (valueType, params) => {
	return new ZodSet({
		valueType,
		minSize: null,
		maxSize: null,
		typeName: ZodFirstPartyTypeKind.ZodSet,
		...processCreateParams(params)
	});
};
var ZodFunction = class ZodFunction extends ZodType {
	constructor() {
		super(...arguments);
		this.validate = this.implement;
	}
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.function) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.function,
				received: ctx.parsedType
			});
			return INVALID;
		}
		function makeArgsIssue(args, error) {
			return makeIssue({
				data: args,
				path: ctx.path,
				errorMaps: [
					ctx.common.contextualErrorMap,
					ctx.schemaErrorMap,
					getErrorMap(),
					en_default
				].filter((x) => !!x),
				issueData: {
					code: ZodIssueCode.invalid_arguments,
					argumentsError: error
				}
			});
		}
		function makeReturnsIssue(returns, error) {
			return makeIssue({
				data: returns,
				path: ctx.path,
				errorMaps: [
					ctx.common.contextualErrorMap,
					ctx.schemaErrorMap,
					getErrorMap(),
					en_default
				].filter((x) => !!x),
				issueData: {
					code: ZodIssueCode.invalid_return_type,
					returnTypeError: error
				}
			});
		}
		const params = { errorMap: ctx.common.contextualErrorMap };
		const fn = ctx.data;
		if (this._def.returns instanceof ZodPromise) {
			const me = this;
			return OK(async function(...args) {
				const error = new ZodError([]);
				const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
					error.addIssue(makeArgsIssue(args, e));
					throw error;
				});
				const result = await Reflect.apply(fn, this, parsedArgs);
				const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
					error.addIssue(makeReturnsIssue(result, e));
					throw error;
				});
				return parsedReturns;
			});
		} else {
			const me = this;
			return OK(function(...args) {
				const parsedArgs = me._def.args.safeParse(args, params);
				if (!parsedArgs.success) throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
				const result = Reflect.apply(fn, this, parsedArgs.data);
				const parsedReturns = me._def.returns.safeParse(result, params);
				if (!parsedReturns.success) throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
				return parsedReturns.data;
			});
		}
	}
	parameters() {
		return this._def.args;
	}
	returnType() {
		return this._def.returns;
	}
	args(...items) {
		return new ZodFunction({
			...this._def,
			args: ZodTuple.create(items).rest(ZodUnknown.create())
		});
	}
	returns(returnType) {
		return new ZodFunction({
			...this._def,
			returns: returnType
		});
	}
	implement(func) {
		const validatedFunc = this.parse(func);
		return validatedFunc;
	}
	strictImplement(func) {
		const validatedFunc = this.parse(func);
		return validatedFunc;
	}
	static create(args, returns, params) {
		return new ZodFunction({
			args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
			returns: returns || ZodUnknown.create(),
			typeName: ZodFirstPartyTypeKind.ZodFunction,
			...processCreateParams(params)
		});
	}
};
var ZodLazy = class extends ZodType {
	get schema() {
		return this._def.getter();
	}
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		const lazySchema = this._def.getter();
		return lazySchema._parse({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		});
	}
};
ZodLazy.create = (getter, params) => {
	return new ZodLazy({
		getter,
		typeName: ZodFirstPartyTypeKind.ZodLazy,
		...processCreateParams(params)
	});
};
var ZodLiteral = class extends ZodType {
	_parse(input) {
		if (input.data !== this._def.value) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				received: ctx.data,
				code: ZodIssueCode.invalid_literal,
				expected: this._def.value
			});
			return INVALID;
		}
		return {
			status: "valid",
			value: input.data
		};
	}
	get value() {
		return this._def.value;
	}
};
ZodLiteral.create = (value, params) => {
	return new ZodLiteral({
		value,
		typeName: ZodFirstPartyTypeKind.ZodLiteral,
		...processCreateParams(params)
	});
};
function createZodEnum(values, params) {
	return new ZodEnum({
		values,
		typeName: ZodFirstPartyTypeKind.ZodEnum,
		...processCreateParams(params)
	});
}
var ZodEnum = class ZodEnum extends ZodType {
	_parse(input) {
		if (typeof input.data !== "string") {
			const ctx = this._getOrReturnCtx(input);
			const expectedValues = this._def.values;
			addIssueToContext(ctx, {
				expected: util.joinValues(expectedValues),
				received: ctx.parsedType,
				code: ZodIssueCode.invalid_type
			});
			return INVALID;
		}
		if (!this._cache) this._cache = new Set(this._def.values);
		if (!this._cache.has(input.data)) {
			const ctx = this._getOrReturnCtx(input);
			const expectedValues = this._def.values;
			addIssueToContext(ctx, {
				received: ctx.data,
				code: ZodIssueCode.invalid_enum_value,
				options: expectedValues
			});
			return INVALID;
		}
		return OK(input.data);
	}
	get options() {
		return this._def.values;
	}
	get enum() {
		const enumValues = {};
		for (const val of this._def.values) enumValues[val] = val;
		return enumValues;
	}
	get Values() {
		const enumValues = {};
		for (const val of this._def.values) enumValues[val] = val;
		return enumValues;
	}
	get Enum() {
		const enumValues = {};
		for (const val of this._def.values) enumValues[val] = val;
		return enumValues;
	}
	extract(values, newDef = this._def) {
		return ZodEnum.create(values, {
			...this._def,
			...newDef
		});
	}
	exclude(values, newDef = this._def) {
		return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
			...this._def,
			...newDef
		});
	}
};
ZodEnum.create = createZodEnum;
var ZodNativeEnum = class extends ZodType {
	_parse(input) {
		const nativeEnumValues = util.getValidEnumValues(this._def.values);
		const ctx = this._getOrReturnCtx(input);
		if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
			const expectedValues = util.objectValues(nativeEnumValues);
			addIssueToContext(ctx, {
				expected: util.joinValues(expectedValues),
				received: ctx.parsedType,
				code: ZodIssueCode.invalid_type
			});
			return INVALID;
		}
		if (!this._cache) this._cache = new Set(util.getValidEnumValues(this._def.values));
		if (!this._cache.has(input.data)) {
			const expectedValues = util.objectValues(nativeEnumValues);
			addIssueToContext(ctx, {
				received: ctx.data,
				code: ZodIssueCode.invalid_enum_value,
				options: expectedValues
			});
			return INVALID;
		}
		return OK(input.data);
	}
	get enum() {
		return this._def.values;
	}
};
ZodNativeEnum.create = (values, params) => {
	return new ZodNativeEnum({
		values,
		typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
		...processCreateParams(params)
	});
};
var ZodPromise = class extends ZodType {
	unwrap() {
		return this._def.type;
	}
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.promise,
				received: ctx.parsedType
			});
			return INVALID;
		}
		const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
		return OK(promisified.then((data) => {
			return this._def.type.parseAsync(data, {
				path: ctx.path,
				errorMap: ctx.common.contextualErrorMap
			});
		}));
	}
};
ZodPromise.create = (schema, params) => {
	return new ZodPromise({
		type: schema,
		typeName: ZodFirstPartyTypeKind.ZodPromise,
		...processCreateParams(params)
	});
};
var ZodEffects = class extends ZodType {
	innerType() {
		return this._def.schema;
	}
	sourceType() {
		return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
	}
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		const effect = this._def.effect || null;
		const checkCtx = {
			addIssue: (arg) => {
				addIssueToContext(ctx, arg);
				if (arg.fatal) status.abort();
				else status.dirty();
			},
			get path() {
				return ctx.path;
			}
		};
		checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
		if (effect.type === "preprocess") {
			const processed = effect.transform(ctx.data, checkCtx);
			if (ctx.common.async) return Promise.resolve(processed).then(async (processed$1) => {
				if (status.value === "aborted") return INVALID;
				const result = await this._def.schema._parseAsync({
					data: processed$1,
					path: ctx.path,
					parent: ctx
				});
				if (result.status === "aborted") return INVALID;
				if (result.status === "dirty") return DIRTY(result.value);
				if (status.value === "dirty") return DIRTY(result.value);
				return result;
			});
			else {
				if (status.value === "aborted") return INVALID;
				const result = this._def.schema._parseSync({
					data: processed,
					path: ctx.path,
					parent: ctx
				});
				if (result.status === "aborted") return INVALID;
				if (result.status === "dirty") return DIRTY(result.value);
				if (status.value === "dirty") return DIRTY(result.value);
				return result;
			}
		}
		if (effect.type === "refinement") {
			const executeRefinement = (acc) => {
				const result = effect.refinement(acc, checkCtx);
				if (ctx.common.async) return Promise.resolve(result);
				if (result instanceof Promise) throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
				return acc;
			};
			if (ctx.common.async === false) {
				const inner = this._def.schema._parseSync({
					data: ctx.data,
					path: ctx.path,
					parent: ctx
				});
				if (inner.status === "aborted") return INVALID;
				if (inner.status === "dirty") status.dirty();
				executeRefinement(inner.value);
				return {
					status: status.value,
					value: inner.value
				};
			} else return this._def.schema._parseAsync({
				data: ctx.data,
				path: ctx.path,
				parent: ctx
			}).then((inner) => {
				if (inner.status === "aborted") return INVALID;
				if (inner.status === "dirty") status.dirty();
				return executeRefinement(inner.value).then(() => {
					return {
						status: status.value,
						value: inner.value
					};
				});
			});
		}
		if (effect.type === "transform") if (ctx.common.async === false) {
			const base = this._def.schema._parseSync({
				data: ctx.data,
				path: ctx.path,
				parent: ctx
			});
			if (!isValid(base)) return INVALID;
			const result = effect.transform(base.value, checkCtx);
			if (result instanceof Promise) throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
			return {
				status: status.value,
				value: result
			};
		} else return this._def.schema._parseAsync({
			data: ctx.data,
			path: ctx.path,
			parent: ctx
		}).then((base) => {
			if (!isValid(base)) return INVALID;
			return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
				status: status.value,
				value: result
			}));
		});
		util.assertNever(effect);
	}
};
ZodEffects.create = (schema, effect, params) => {
	return new ZodEffects({
		schema,
		typeName: ZodFirstPartyTypeKind.ZodEffects,
		effect,
		...processCreateParams(params)
	});
};
ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
	return new ZodEffects({
		schema,
		effect: {
			type: "preprocess",
			transform: preprocess
		},
		typeName: ZodFirstPartyTypeKind.ZodEffects,
		...processCreateParams(params)
	});
};
var ZodOptional = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType === ZodParsedType.undefined) return OK(void 0);
		return this._def.innerType._parse(input);
	}
	unwrap() {
		return this._def.innerType;
	}
};
ZodOptional.create = (type, params) => {
	return new ZodOptional({
		innerType: type,
		typeName: ZodFirstPartyTypeKind.ZodOptional,
		...processCreateParams(params)
	});
};
var ZodNullable = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType === ZodParsedType.null) return OK(null);
		return this._def.innerType._parse(input);
	}
	unwrap() {
		return this._def.innerType;
	}
};
ZodNullable.create = (type, params) => {
	return new ZodNullable({
		innerType: type,
		typeName: ZodFirstPartyTypeKind.ZodNullable,
		...processCreateParams(params)
	});
};
var ZodDefault = class extends ZodType {
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		let data = ctx.data;
		if (ctx.parsedType === ZodParsedType.undefined) data = this._def.defaultValue();
		return this._def.innerType._parse({
			data,
			path: ctx.path,
			parent: ctx
		});
	}
	removeDefault() {
		return this._def.innerType;
	}
};
ZodDefault.create = (type, params) => {
	return new ZodDefault({
		innerType: type,
		typeName: ZodFirstPartyTypeKind.ZodDefault,
		defaultValue: typeof params.default === "function" ? params.default : () => params.default,
		...processCreateParams(params)
	});
};
var ZodCatch = class extends ZodType {
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		const newCtx = {
			...ctx,
			common: {
				...ctx.common,
				issues: []
			}
		};
		const result = this._def.innerType._parse({
			data: newCtx.data,
			path: newCtx.path,
			parent: { ...newCtx }
		});
		if (isAsync(result)) return result.then((result$1) => {
			return {
				status: "valid",
				value: result$1.status === "valid" ? result$1.value : this._def.catchValue({
					get error() {
						return new ZodError(newCtx.common.issues);
					},
					input: newCtx.data
				})
			};
		});
		else return {
			status: "valid",
			value: result.status === "valid" ? result.value : this._def.catchValue({
				get error() {
					return new ZodError(newCtx.common.issues);
				},
				input: newCtx.data
			})
		};
	}
	removeCatch() {
		return this._def.innerType;
	}
};
ZodCatch.create = (type, params) => {
	return new ZodCatch({
		innerType: type,
		typeName: ZodFirstPartyTypeKind.ZodCatch,
		catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
		...processCreateParams(params)
	});
};
var ZodNaN = class extends ZodType {
	_parse(input) {
		const parsedType = this._getType(input);
		if (parsedType !== ZodParsedType.nan) {
			const ctx = this._getOrReturnCtx(input);
			addIssueToContext(ctx, {
				code: ZodIssueCode.invalid_type,
				expected: ZodParsedType.nan,
				received: ctx.parsedType
			});
			return INVALID;
		}
		return {
			status: "valid",
			value: input.data
		};
	}
};
ZodNaN.create = (params) => {
	return new ZodNaN({
		typeName: ZodFirstPartyTypeKind.ZodNaN,
		...processCreateParams(params)
	});
};
const BRAND = Symbol("zod_brand");
var ZodBranded = class extends ZodType {
	_parse(input) {
		const { ctx } = this._processInputParams(input);
		const data = ctx.data;
		return this._def.type._parse({
			data,
			path: ctx.path,
			parent: ctx
		});
	}
	unwrap() {
		return this._def.type;
	}
};
var ZodPipeline = class ZodPipeline extends ZodType {
	_parse(input) {
		const { status, ctx } = this._processInputParams(input);
		if (ctx.common.async) {
			const handleAsync = async () => {
				const inResult = await this._def.in._parseAsync({
					data: ctx.data,
					path: ctx.path,
					parent: ctx
				});
				if (inResult.status === "aborted") return INVALID;
				if (inResult.status === "dirty") {
					status.dirty();
					return DIRTY(inResult.value);
				} else return this._def.out._parseAsync({
					data: inResult.value,
					path: ctx.path,
					parent: ctx
				});
			};
			return handleAsync();
		} else {
			const inResult = this._def.in._parseSync({
				data: ctx.data,
				path: ctx.path,
				parent: ctx
			});
			if (inResult.status === "aborted") return INVALID;
			if (inResult.status === "dirty") {
				status.dirty();
				return {
					status: "dirty",
					value: inResult.value
				};
			} else return this._def.out._parseSync({
				data: inResult.value,
				path: ctx.path,
				parent: ctx
			});
		}
	}
	static create(a, b) {
		return new ZodPipeline({
			in: a,
			out: b,
			typeName: ZodFirstPartyTypeKind.ZodPipeline
		});
	}
};
var ZodReadonly = class extends ZodType {
	_parse(input) {
		const result = this._def.innerType._parse(input);
		const freeze = (data) => {
			if (isValid(data)) data.value = Object.freeze(data.value);
			return data;
		};
		return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
	}
	unwrap() {
		return this._def.innerType;
	}
};
ZodReadonly.create = (type, params) => {
	return new ZodReadonly({
		innerType: type,
		typeName: ZodFirstPartyTypeKind.ZodReadonly,
		...processCreateParams(params)
	});
};
function cleanParams(params, data) {
	const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
	const p2 = typeof p === "string" ? { message: p } : p;
	return p2;
}
function custom(check, _params = {}, fatal) {
	if (check) return ZodAny.create().superRefine((data, ctx) => {
		const r = check(data);
		if (r instanceof Promise) return r.then((r$1) => {
			if (!r$1) {
				const params = cleanParams(_params, data);
				const _fatal = params.fatal ?? fatal ?? true;
				ctx.addIssue({
					code: "custom",
					...params,
					fatal: _fatal
				});
			}
		});
		if (!r) {
			const params = cleanParams(_params, data);
			const _fatal = params.fatal ?? fatal ?? true;
			ctx.addIssue({
				code: "custom",
				...params,
				fatal: _fatal
			});
		}
		return;
	});
	return ZodAny.create();
}
const late = { object: ZodObject.lazycreate };
var ZodFirstPartyTypeKind;
(function(ZodFirstPartyTypeKind$1) {
	ZodFirstPartyTypeKind$1["ZodString"] = "ZodString";
	ZodFirstPartyTypeKind$1["ZodNumber"] = "ZodNumber";
	ZodFirstPartyTypeKind$1["ZodNaN"] = "ZodNaN";
	ZodFirstPartyTypeKind$1["ZodBigInt"] = "ZodBigInt";
	ZodFirstPartyTypeKind$1["ZodBoolean"] = "ZodBoolean";
	ZodFirstPartyTypeKind$1["ZodDate"] = "ZodDate";
	ZodFirstPartyTypeKind$1["ZodSymbol"] = "ZodSymbol";
	ZodFirstPartyTypeKind$1["ZodUndefined"] = "ZodUndefined";
	ZodFirstPartyTypeKind$1["ZodNull"] = "ZodNull";
	ZodFirstPartyTypeKind$1["ZodAny"] = "ZodAny";
	ZodFirstPartyTypeKind$1["ZodUnknown"] = "ZodUnknown";
	ZodFirstPartyTypeKind$1["ZodNever"] = "ZodNever";
	ZodFirstPartyTypeKind$1["ZodVoid"] = "ZodVoid";
	ZodFirstPartyTypeKind$1["ZodArray"] = "ZodArray";
	ZodFirstPartyTypeKind$1["ZodObject"] = "ZodObject";
	ZodFirstPartyTypeKind$1["ZodUnion"] = "ZodUnion";
	ZodFirstPartyTypeKind$1["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
	ZodFirstPartyTypeKind$1["ZodIntersection"] = "ZodIntersection";
	ZodFirstPartyTypeKind$1["ZodTuple"] = "ZodTuple";
	ZodFirstPartyTypeKind$1["ZodRecord"] = "ZodRecord";
	ZodFirstPartyTypeKind$1["ZodMap"] = "ZodMap";
	ZodFirstPartyTypeKind$1["ZodSet"] = "ZodSet";
	ZodFirstPartyTypeKind$1["ZodFunction"] = "ZodFunction";
	ZodFirstPartyTypeKind$1["ZodLazy"] = "ZodLazy";
	ZodFirstPartyTypeKind$1["ZodLiteral"] = "ZodLiteral";
	ZodFirstPartyTypeKind$1["ZodEnum"] = "ZodEnum";
	ZodFirstPartyTypeKind$1["ZodEffects"] = "ZodEffects";
	ZodFirstPartyTypeKind$1["ZodNativeEnum"] = "ZodNativeEnum";
	ZodFirstPartyTypeKind$1["ZodOptional"] = "ZodOptional";
	ZodFirstPartyTypeKind$1["ZodNullable"] = "ZodNullable";
	ZodFirstPartyTypeKind$1["ZodDefault"] = "ZodDefault";
	ZodFirstPartyTypeKind$1["ZodCatch"] = "ZodCatch";
	ZodFirstPartyTypeKind$1["ZodPromise"] = "ZodPromise";
	ZodFirstPartyTypeKind$1["ZodBranded"] = "ZodBranded";
	ZodFirstPartyTypeKind$1["ZodPipeline"] = "ZodPipeline";
	ZodFirstPartyTypeKind$1["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
const stringType = ZodString.create;
const numberType = ZodNumber.create;
const nanType = ZodNaN.create;
const bigIntType = ZodBigInt.create;
const booleanType = ZodBoolean.create;
const dateType = ZodDate.create;
const symbolType = ZodSymbol.create;
const undefinedType = ZodUndefined.create;
const nullType = ZodNull.create;
const anyType = ZodAny.create;
const unknownType = ZodUnknown.create;
const neverType = ZodNever.create;
const voidType = ZodVoid.create;
const arrayType = ZodArray.create;
const objectType = ZodObject.create;
const strictObjectType = ZodObject.strictCreate;
const unionType = ZodUnion.create;
const discriminatedUnionType = ZodDiscriminatedUnion.create;
const intersectionType = ZodIntersection.create;
const tupleType = ZodTuple.create;
const recordType = ZodRecord.create;
const mapType = ZodMap.create;
const setType = ZodSet.create;
const functionType = ZodFunction.create;
const lazyType = ZodLazy.create;
const literalType = ZodLiteral.create;
const enumType = ZodEnum.create;
const nativeEnumType = ZodNativeEnum.create;
const promiseType = ZodPromise.create;
const effectsType = ZodEffects.create;
const optionalType = ZodOptional.create;
const nullableType = ZodNullable.create;
const preprocessType = ZodEffects.createWithPreprocess;
const pipelineType = ZodPipeline.create;

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/fast-json-patch/src/helpers.js
/*!
* https://github.com/Starcounter-Jack/JSON-Patch
* (c) 2017-2022 Joachim Wester
* MIT licensed
*/
const _hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwnProperty(obj, key) {
	return _hasOwnProperty.call(obj, key);
}
function _objectKeys(obj) {
	if (Array.isArray(obj)) {
		const keys$1 = new Array(obj.length);
		for (let k = 0; k < keys$1.length; k++) keys$1[k] = "" + k;
		return keys$1;
	}
	if (Object.keys) return Object.keys(obj);
	let keys = [];
	for (let i in obj) if (hasOwnProperty(obj, i)) keys.push(i);
	return keys;
}
/**
* Deeply clone the object.
* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
* @param  {any} obj value to clone
* @return {any} cloned obj
*/
function _deepClone(obj) {
	switch (typeof obj) {
		case "object": return JSON.parse(JSON.stringify(obj));
		case "undefined": return null;
		default: return obj;
	}
}
function isInteger(str) {
	let i = 0;
	const len = str.length;
	let charCode;
	while (i < len) {
		charCode = str.charCodeAt(i);
		if (charCode >= 48 && charCode <= 57) {
			i++;
			continue;
		}
		return false;
	}
	return true;
}
/**
* Escapes a json pointer path
* @param path The raw pointer
* @return the Escaped path
*/
function escapePathComponent(path) {
	if (path.indexOf("/") === -1 && path.indexOf("~") === -1) return path;
	return path.replace(/~/g, "~0").replace(/\//g, "~1");
}
/**
* Unescapes a json pointer path
* @param path The escaped pointer
* @return The unescaped path
*/
function unescapePathComponent(path) {
	return path.replace(/~1/g, "/").replace(/~0/g, "~");
}
/**
* Recursively checks whether an object has any undefined values inside.
*/
function hasUndefined(obj) {
	if (obj === void 0) return true;
	if (obj) {
		if (Array.isArray(obj)) {
			for (let i$1 = 0, len = obj.length; i$1 < len; i$1++) if (hasUndefined(obj[i$1])) return true;
		} else if (typeof obj === "object") {
			const objKeys = _objectKeys(obj);
			const objKeysLength = objKeys.length;
			for (var i = 0; i < objKeysLength; i++) if (hasUndefined(obj[objKeys[i]])) return true;
		}
	}
	return false;
}
function patchErrorMessageFormatter(message, args) {
	const messageParts = [message];
	for (const key in args) {
		const value = typeof args[key] === "object" ? JSON.stringify(args[key], null, 2) : args[key];
		if (typeof value !== "undefined") messageParts.push(`${key}: ${value}`);
	}
	return messageParts.join("\n");
}
var PatchError = class extends Error {
	constructor(message, name, index, operation, tree) {
		super(patchErrorMessageFormatter(message, {
			name,
			index,
			operation,
			tree
		}));
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: name
		});
		Object.defineProperty(this, "index", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: index
		});
		Object.defineProperty(this, "operation", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: operation
		});
		Object.defineProperty(this, "tree", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: tree
		});
		Object.setPrototypeOf(this, new.target.prototype);
		this.message = patchErrorMessageFormatter(message, {
			name,
			index,
			operation,
			tree
		});
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/fast-json-patch/src/core.js
var core_exports = {};
__export(core_exports, {
	JsonPatchError: () => JsonPatchError,
	_areEquals: () => _areEquals,
	applyOperation: () => applyOperation,
	applyPatch: () => applyPatch,
	applyReducer: () => applyReducer,
	deepClone: () => deepClone,
	getValueByPointer: () => getValueByPointer,
	validate: () => validate,
	validator: () => validator
});
const JsonPatchError = PatchError;
const deepClone = _deepClone;
const objOps = {
	add: function(obj, key, document) {
		obj[key] = this.value;
		return { newDocument: document };
	},
	remove: function(obj, key, document) {
		var removed = obj[key];
		delete obj[key];
		return {
			newDocument: document,
			removed
		};
	},
	replace: function(obj, key, document) {
		var removed = obj[key];
		obj[key] = this.value;
		return {
			newDocument: document,
			removed
		};
	},
	move: function(obj, key, document) {
		let removed = getValueByPointer(document, this.path);
		if (removed) removed = _deepClone(removed);
		const originalValue = applyOperation(document, {
			op: "remove",
			path: this.from
		}).removed;
		applyOperation(document, {
			op: "add",
			path: this.path,
			value: originalValue
		});
		return {
			newDocument: document,
			removed
		};
	},
	copy: function(obj, key, document) {
		const valueToCopy = getValueByPointer(document, this.from);
		applyOperation(document, {
			op: "add",
			path: this.path,
			value: _deepClone(valueToCopy)
		});
		return { newDocument: document };
	},
	test: function(obj, key, document) {
		return {
			newDocument: document,
			test: _areEquals(obj[key], this.value)
		};
	},
	_get: function(obj, key, document) {
		this.value = obj[key];
		return { newDocument: document };
	}
};
var arrOps = {
	add: function(arr$1, i, document) {
		if (isInteger(i)) arr$1.splice(i, 0, this.value);
		else arr$1[i] = this.value;
		return {
			newDocument: document,
			index: i
		};
	},
	remove: function(arr$1, i, document) {
		var removedList = arr$1.splice(i, 1);
		return {
			newDocument: document,
			removed: removedList[0]
		};
	},
	replace: function(arr$1, i, document) {
		var removed = arr$1[i];
		arr$1[i] = this.value;
		return {
			newDocument: document,
			removed
		};
	},
	move: objOps.move,
	copy: objOps.copy,
	test: objOps.test,
	_get: objOps._get
};
/**
* Retrieves a value from a JSON document by a JSON pointer.
* Returns the value.
*
* @param document The document to get the value from
* @param pointer an escaped JSON pointer
* @return The retrieved value
*/
function getValueByPointer(document, pointer) {
	if (pointer == "") return document;
	var getOriginalDestination = {
		op: "_get",
		path: pointer
	};
	applyOperation(document, getOriginalDestination);
	return getOriginalDestination.value;
}
/**
* Apply a single JSON Patch Operation on a JSON document.
* Returns the {newDocument, result} of the operation.
* It modifies the `document` and `operation` objects - it gets the values by reference.
* If you would like to avoid touching your values, clone them:
* `jsonpatch.applyOperation(document, jsonpatch._deepClone(operation))`.
*
* @param document The document to patch
* @param operation The operation to apply
* @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
* @param mutateDocument Whether to mutate the original document or clone it before applying
* @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
* @return `{newDocument, result}` after the operation
*/
function applyOperation(document, operation, validateOperation = false, mutateDocument = true, banPrototypeModifications = true, index = 0) {
	if (validateOperation) if (typeof validateOperation == "function") validateOperation(operation, 0, document, operation.path);
	else validator(operation, 0);
	if (operation.path === "") {
		let returnValue = { newDocument: document };
		if (operation.op === "add") {
			returnValue.newDocument = operation.value;
			return returnValue;
		} else if (operation.op === "replace") {
			returnValue.newDocument = operation.value;
			returnValue.removed = document;
			return returnValue;
		} else if (operation.op === "move" || operation.op === "copy") {
			returnValue.newDocument = getValueByPointer(document, operation.from);
			if (operation.op === "move") returnValue.removed = document;
			return returnValue;
		} else if (operation.op === "test") {
			returnValue.test = _areEquals(document, operation.value);
			if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
			returnValue.newDocument = document;
			return returnValue;
		} else if (operation.op === "remove") {
			returnValue.removed = document;
			returnValue.newDocument = null;
			return returnValue;
		} else if (operation.op === "_get") {
			operation.value = document;
			return returnValue;
		} else if (validateOperation) throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
		else return returnValue;
	} else {
		if (!mutateDocument) document = _deepClone(document);
		const path = operation.path || "";
		const keys = path.split("/");
		let obj = document;
		let t$5 = 1;
		let len = keys.length;
		let existingPathFragment = void 0;
		let key;
		let validateFunction;
		if (typeof validateOperation == "function") validateFunction = validateOperation;
		else validateFunction = validator;
		while (true) {
			key = keys[t$5];
			if (key && key.indexOf("~") != -1) key = unescapePathComponent(key);
			if (banPrototypeModifications && (key == "__proto__" || key == "prototype" && t$5 > 0 && keys[t$5 - 1] == "constructor")) throw new TypeError("JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README");
			if (validateOperation) {
				if (existingPathFragment === void 0) {
					if (obj[key] === void 0) existingPathFragment = keys.slice(0, t$5).join("/");
					else if (t$5 == len - 1) existingPathFragment = operation.path;
					if (existingPathFragment !== void 0) validateFunction(operation, 0, document, existingPathFragment);
				}
			}
			t$5++;
			if (Array.isArray(obj)) {
				if (key === "-") key = obj.length;
				else if (validateOperation && !isInteger(key)) throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document);
				else if (isInteger(key)) key = ~~key;
				if (t$5 >= len) {
					if (validateOperation && operation.op === "add" && key > obj.length) throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document);
					const returnValue = arrOps[operation.op].call(operation, obj, key, document);
					if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
					return returnValue;
				}
			} else if (t$5 >= len) {
				const returnValue = objOps[operation.op].call(operation, obj, key, document);
				if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
				return returnValue;
			}
			obj = obj[key];
			if (validateOperation && t$5 < len && (!obj || typeof obj !== "object")) throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
		}
	}
}
/**
* Apply a full JSON Patch array on a JSON document.
* Returns the {newDocument, result} of the patch.
* It modifies the `document` object and `patch` - it gets the values by reference.
* If you would like to avoid touching your values, clone them:
* `jsonpatch.applyPatch(document, jsonpatch._deepClone(patch))`.
*
* @param document The document to patch
* @param patch The patch to apply
* @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
* @param mutateDocument Whether to mutate the original document or clone it before applying
* @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
* @return An array of `{newDocument, result}` after the patch
*/
function applyPatch(document, patch$2, validateOperation, mutateDocument = true, banPrototypeModifications = true) {
	if (validateOperation) {
		if (!Array.isArray(patch$2)) throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
	}
	if (!mutateDocument) document = _deepClone(document);
	const results = new Array(patch$2.length);
	for (let i = 0, length = patch$2.length; i < length; i++) {
		results[i] = applyOperation(document, patch$2[i], validateOperation, true, banPrototypeModifications, i);
		document = results[i].newDocument;
	}
	results.newDocument = document;
	return results;
}
/**
* Apply a single JSON Patch Operation on a JSON document.
* Returns the updated document.
* Suitable as a reducer.
*
* @param document The document to patch
* @param operation The operation to apply
* @return The updated document
*/
function applyReducer(document, operation, index) {
	const operationResult = applyOperation(document, operation);
	if (operationResult.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
	return operationResult.newDocument;
}
/**
* Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error.
* @param {object} operation - operation object (patch)
* @param {number} index - index of operation in the sequence
* @param {object} [document] - object where the operation is supposed to be applied
* @param {string} [existingPathFragment] - comes along with `document`
*/
function validator(operation, index, document, existingPathFragment) {
	if (typeof operation !== "object" || operation === null || Array.isArray(operation)) throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document);
	else if (!objOps[operation.op]) throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
	else if (typeof operation.path !== "string") throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document);
	else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) throw new JsonPatchError("Operation `path` property must start with \"/\"", "OPERATION_PATH_INVALID", index, operation, document);
	else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document);
	else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === void 0) throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document);
	else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document);
	else if (document) {
		if (operation.op == "add") {
			var pathLen = operation.path.split("/").length;
			var existingPathLen = existingPathFragment.split("/").length;
			if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document);
		} else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
			if (operation.path !== existingPathFragment) throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
		} else if (operation.op === "move" || operation.op === "copy") {
			var existingValue = {
				op: "_get",
				path: operation.from,
				value: void 0
			};
			var error = validate([existingValue], document);
			if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document);
		}
	}
}
/**
* Validates a sequence of operations. If `document` parameter is provided, the sequence is additionally validated against the object document.
* If error is encountered, returns a JsonPatchError object
* @param sequence
* @param document
* @returns {JsonPatchError|undefined}
*/
function validate(sequence, document, externalValidator) {
	try {
		if (!Array.isArray(sequence)) throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
		if (document) applyPatch(_deepClone(document), _deepClone(sequence), externalValidator || true);
		else {
			externalValidator = externalValidator || validator;
			for (var i = 0; i < sequence.length; i++) externalValidator(sequence[i], i, document, void 0);
		}
	} catch (e) {
		if (e instanceof JsonPatchError) return e;
		else throw e;
	}
}
function _areEquals(a, b) {
	if (a === b) return true;
	if (a && b && typeof a == "object" && typeof b == "object") {
		var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key;
		if (arrA && arrB) {
			length = a.length;
			if (length != b.length) return false;
			for (i = length; i-- !== 0;) if (!_areEquals(a[i], b[i])) return false;
			return true;
		}
		if (arrA != arrB) return false;
		var keys = Object.keys(a);
		length = keys.length;
		if (length !== Object.keys(b).length) return false;
		for (i = length; i-- !== 0;) if (!b.hasOwnProperty(keys[i])) return false;
		for (i = length; i-- !== 0;) {
			key = keys[i];
			if (!_areEquals(a[key], b[key])) return false;
		}
		return true;
	}
	return a !== a && b !== b;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/fast-json-patch/src/duplex.js
function _generate(mirror, obj, patches, path, invertible) {
	if (obj === mirror) return;
	if (typeof obj.toJSON === "function") obj = obj.toJSON();
	var newKeys = _objectKeys(obj);
	var oldKeys = _objectKeys(mirror);
	var changed = false;
	var deleted = false;
	for (var t$5 = oldKeys.length - 1; t$5 >= 0; t$5--) {
		var key = oldKeys[t$5];
		var oldVal = mirror[key];
		if (hasOwnProperty(obj, key) && !(obj[key] === void 0 && oldVal !== void 0 && Array.isArray(obj) === false)) {
			var newVal = obj[key];
			if (typeof oldVal == "object" && oldVal != null && typeof newVal == "object" && newVal != null && Array.isArray(oldVal) === Array.isArray(newVal)) _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
			else if (oldVal !== newVal) {
				changed = true;
				if (invertible) patches.push({
					op: "test",
					path: path + "/" + escapePathComponent(key),
					value: _deepClone(oldVal)
				});
				patches.push({
					op: "replace",
					path: path + "/" + escapePathComponent(key),
					value: _deepClone(newVal)
				});
			}
		} else if (Array.isArray(mirror) === Array.isArray(obj)) {
			if (invertible) patches.push({
				op: "test",
				path: path + "/" + escapePathComponent(key),
				value: _deepClone(oldVal)
			});
			patches.push({
				op: "remove",
				path: path + "/" + escapePathComponent(key)
			});
			deleted = true;
		} else {
			if (invertible) patches.push({
				op: "test",
				path,
				value: mirror
			});
			patches.push({
				op: "replace",
				path,
				value: obj
			});
			changed = true;
		}
	}
	if (!deleted && newKeys.length == oldKeys.length) return;
	for (var t$5 = 0; t$5 < newKeys.length; t$5++) {
		var key = newKeys[t$5];
		if (!hasOwnProperty(mirror, key) && obj[key] !== void 0) patches.push({
			op: "add",
			path: path + "/" + escapePathComponent(key),
			value: _deepClone(obj[key])
		});
	}
}
/**
* Create an array of patches from the differences in two objects
*/
function compare(tree1, tree2, invertible = false) {
	var patches = [];
	_generate(tree1, tree2, patches, "", invertible);
	return patches;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/fast-json-patch/index.js
var fast_json_patch_default = {
	...core_exports,
	JsonPatchError: PatchError,
	deepClone: _deepClone,
	escapePathComponent,
	unescapePathComponent
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/config.js
const DEFAULT_RECURSION_LIMIT = 25;
async function getCallbackManagerForConfig(config) {
	return CallbackManager._configureSync(config?.callbacks, void 0, config?.tags, void 0, config?.metadata);
}
function mergeConfigs(...configs) {
	const copy = {};
	for (const options of configs.filter((c) => !!c)) for (const key of Object.keys(options)) if (key === "metadata") copy[key] = {
		...copy[key],
		...options[key]
	};
	else if (key === "tags") {
		const baseKeys = copy[key] ?? [];
		copy[key] = [...new Set(baseKeys.concat(options[key] ?? []))];
	} else if (key === "configurable") copy[key] = {
		...copy[key],
		...options[key]
	};
	else if (key === "timeout") {
		if (copy.timeout === void 0) copy.timeout = options.timeout;
		else if (options.timeout !== void 0) copy.timeout = Math.min(copy.timeout, options.timeout);
	} else if (key === "signal") {
		if (copy.signal === void 0) copy.signal = options.signal;
		else if (options.signal !== void 0) if ("any" in AbortSignal) copy.signal = AbortSignal.any([copy.signal, options.signal]);
		else copy.signal = options.signal;
	} else if (key === "callbacks") {
		const baseCallbacks = copy.callbacks;
		const providedCallbacks = options.callbacks;
		if (Array.isArray(providedCallbacks)) if (!baseCallbacks) copy.callbacks = providedCallbacks;
		else if (Array.isArray(baseCallbacks)) copy.callbacks = baseCallbacks.concat(providedCallbacks);
		else {
			const manager = baseCallbacks.copy();
			for (const callback of providedCallbacks) manager.addHandler(ensureHandler(callback), true);
			copy.callbacks = manager;
		}
		else if (providedCallbacks) if (!baseCallbacks) copy.callbacks = providedCallbacks;
		else if (Array.isArray(baseCallbacks)) {
			const manager = providedCallbacks.copy();
			for (const callback of baseCallbacks) manager.addHandler(ensureHandler(callback), true);
			copy.callbacks = manager;
		} else copy.callbacks = new CallbackManager(providedCallbacks._parentRunId, {
			handlers: baseCallbacks.handlers.concat(providedCallbacks.handlers),
			inheritableHandlers: baseCallbacks.inheritableHandlers.concat(providedCallbacks.inheritableHandlers),
			tags: Array.from(new Set(baseCallbacks.tags.concat(providedCallbacks.tags))),
			inheritableTags: Array.from(new Set(baseCallbacks.inheritableTags.concat(providedCallbacks.inheritableTags))),
			metadata: {
				...baseCallbacks.metadata,
				...providedCallbacks.metadata
			}
		});
	} else {
		const typedKey = key;
		copy[typedKey] = options[typedKey] ?? copy[typedKey];
	}
	return copy;
}
const PRIMITIVES = new Set([
	"string",
	"number",
	"boolean"
]);
/**
* Ensure that a passed config is an object with all required keys present.
*/
function ensureConfig(config) {
	const implicitConfig = AsyncLocalStorageProviderSingleton.getRunnableConfig();
	let empty$1 = {
		tags: [],
		metadata: {},
		recursionLimit: 25,
		runId: void 0
	};
	if (implicitConfig) {
		const { runId, runName,...rest } = implicitConfig;
		empty$1 = Object.entries(rest).reduce((currentConfig, [key, value]) => {
			if (value !== void 0) currentConfig[key] = value;
			return currentConfig;
		}, empty$1);
	}
	if (config) empty$1 = Object.entries(config).reduce((currentConfig, [key, value]) => {
		if (value !== void 0) currentConfig[key] = value;
		return currentConfig;
	}, empty$1);
	if (empty$1?.configurable) {
		for (const key of Object.keys(empty$1.configurable)) if (PRIMITIVES.has(typeof empty$1.configurable[key]) && !empty$1.metadata?.[key]) {
			if (!empty$1.metadata) empty$1.metadata = {};
			empty$1.metadata[key] = empty$1.configurable[key];
		}
	}
	if (empty$1.timeout !== void 0) {
		if (empty$1.timeout <= 0) throw new Error("Timeout must be a positive number");
		const timeoutSignal = AbortSignal.timeout(empty$1.timeout);
		if (empty$1.signal !== void 0) {
			if ("any" in AbortSignal) empty$1.signal = AbortSignal.any([empty$1.signal, timeoutSignal]);
		} else empty$1.signal = timeoutSignal;
		delete empty$1.timeout;
	}
	return empty$1;
}
/**
* Helper function that patches runnable configs with updated properties.
*/
function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, runId } = {}) {
	const newConfig = ensureConfig(config);
	if (callbacks !== void 0) {
		/**
		* If we're replacing callbacks we need to unset runName
		* since that should apply only to the same run as the original callbacks
		*/
		delete newConfig.runName;
		newConfig.callbacks = callbacks;
	}
	if (recursionLimit !== void 0) newConfig.recursionLimit = recursionLimit;
	if (maxConcurrency !== void 0) newConfig.maxConcurrency = maxConcurrency;
	if (runName !== void 0) newConfig.runName = runName;
	if (configurable !== void 0) newConfig.configurable = {
		...newConfig.configurable,
		...configurable
	};
	if (runId !== void 0) delete newConfig.runId;
	return newConfig;
}
function pickRunnableConfigKeys(config) {
	return config ? {
		configurable: config.configurable,
		recursionLimit: config.recursionLimit,
		callbacks: config.callbacks,
		tags: config.tags,
		metadata: config.metadata,
		maxConcurrency: config.maxConcurrency,
		timeout: config.timeout,
		signal: config.signal
	} : void 0;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/signal.js
async function raceWithSignal(promise, signal) {
	if (signal === void 0) return promise;
	let listener;
	return Promise.race([promise.catch((err) => {
		if (!signal?.aborted) throw err;
		else return void 0;
	}), new Promise((_, reject) => {
		listener = () => {
			reject(new Error("Aborted"));
		};
		signal.addEventListener("abort", listener);
		if (signal.aborted) reject(new Error("Aborted"));
	})]).finally(() => signal.removeEventListener("abort", listener));
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/stream.js
var stream_exports = {};
__export(stream_exports, {
	AsyncGeneratorWithSetup: () => AsyncGeneratorWithSetup,
	IterableReadableStream: () => IterableReadableStream,
	atee: () => atee,
	concat: () => concat,
	pipeGeneratorWithSetup: () => pipeGeneratorWithSetup
});
var IterableReadableStream = class IterableReadableStream extends ReadableStream {
	constructor() {
		super(...arguments);
		Object.defineProperty(this, "reader", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
	}
	ensureReader() {
		if (!this.reader) this.reader = this.getReader();
	}
	async next() {
		this.ensureReader();
		try {
			const result = await this.reader.read();
			if (result.done) {
				this.reader.releaseLock();
				return {
					done: true,
					value: void 0
				};
			} else return {
				done: false,
				value: result.value
			};
		} catch (e) {
			this.reader.releaseLock();
			throw e;
		}
	}
	async return() {
		this.ensureReader();
		if (this.locked) {
			const cancelPromise = this.reader.cancel();
			this.reader.releaseLock();
			await cancelPromise;
		}
		return {
			done: true,
			value: void 0
		};
	}
	async throw(e) {
		this.ensureReader();
		if (this.locked) {
			const cancelPromise = this.reader.cancel();
			this.reader.releaseLock();
			await cancelPromise;
		}
		throw e;
	}
	[Symbol.asyncIterator]() {
		return this;
	}
	async [Symbol.asyncDispose]() {
		await this.return();
	}
	static fromReadableStream(stream) {
		const reader = stream.getReader();
		return new IterableReadableStream({
			start(controller) {
				return pump();
				function pump() {
					return reader.read().then(({ done, value }) => {
						if (done) {
							controller.close();
							return;
						}
						controller.enqueue(value);
						return pump();
					});
				}
			},
			cancel() {
				reader.releaseLock();
			}
		});
	}
	static fromAsyncGenerator(generator) {
		return new IterableReadableStream({
			async pull(controller) {
				const { value, done } = await generator.next();
				if (done) controller.close();
				controller.enqueue(value);
			},
			async cancel(reason) {
				await generator.return(reason);
			}
		});
	}
};
function atee(iter, length = 2) {
	const buffers = Array.from({ length }, () => []);
	return buffers.map(async function* makeIter(buffer) {
		while (true) if (buffer.length === 0) {
			const result = await iter.next();
			for (const buffer$1 of buffers) buffer$1.push(result);
		} else if (buffer[0].done) return;
		else yield buffer.shift().value;
	});
}
function concat(first, second) {
	if (Array.isArray(first) && Array.isArray(second)) return first.concat(second);
	else if (typeof first === "string" && typeof second === "string") return first + second;
	else if (typeof first === "number" && typeof second === "number") return first + second;
	else if ("concat" in first && typeof first.concat === "function") return first.concat(second);
	else if (typeof first === "object" && typeof second === "object") {
		const chunk = { ...first };
		for (const [key, value] of Object.entries(second)) if (key in chunk && !Array.isArray(chunk[key])) chunk[key] = concat(chunk[key], value);
		else chunk[key] = value;
		return chunk;
	} else throw new Error(`Cannot concat ${typeof first} and ${typeof second}`);
}
var AsyncGeneratorWithSetup = class {
	constructor(params) {
		Object.defineProperty(this, "generator", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "setup", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "config", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "signal", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "firstResult", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "firstResultUsed", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		this.generator = params.generator;
		this.config = params.config;
		this.signal = params.signal ?? this.config?.signal;
		this.setup = new Promise((resolve, reject) => {
			AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(params.config), async () => {
				this.firstResult = params.generator.next();
				if (params.startSetup) this.firstResult.then(params.startSetup).then(resolve, reject);
				else this.firstResult.then((_result) => resolve(void 0), reject);
			}, true);
		});
	}
	async next(...args) {
		this.signal?.throwIfAborted();
		if (!this.firstResultUsed) {
			this.firstResultUsed = true;
			return this.firstResult;
		}
		return AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(this.config), this.signal ? async () => {
			return raceWithSignal(this.generator.next(...args), this.signal);
		} : async () => {
			return this.generator.next(...args);
		}, true);
	}
	async return(value) {
		return this.generator.return(value);
	}
	async throw(e) {
		return this.generator.throw(e);
	}
	[Symbol.asyncIterator]() {
		return this;
	}
	async [Symbol.asyncDispose]() {
		await this.return();
	}
};
async function pipeGeneratorWithSetup(to, generator, startSetup, signal, ...args) {
	const gen = new AsyncGeneratorWithSetup({
		generator,
		startSetup,
		signal
	});
	const setup = await gen.setup;
	return {
		output: to(gen, setup, ...args),
		setup
	};
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tracers/log_stream.js
var log_stream_exports = {};
__export(log_stream_exports, {
	LogStreamCallbackHandler: () => LogStreamCallbackHandler,
	RunLog: () => RunLog,
	RunLogPatch: () => RunLogPatch,
	isLogStreamHandler: () => isLogStreamHandler
});
/**
* List of jsonpatch JSONPatchOperations, which describe how to create the run state
* from an empty dict. This is the minimal representation of the log, designed to
* be serialized as JSON and sent over the wire to reconstruct the log on the other
* side. Reconstruction of the state can be done with any jsonpatch-compliant library,
* see https://jsonpatch.com for more information.
*/
var RunLogPatch = class {
	constructor(fields) {
		Object.defineProperty(this, "ops", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.ops = fields.ops ?? [];
	}
	concat(other) {
		const ops = this.ops.concat(other.ops);
		const states = applyPatch({}, ops);
		return new RunLog({
			ops,
			state: states[states.length - 1].newDocument
		});
	}
};
var RunLog = class RunLog extends RunLogPatch {
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "state", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.state = fields.state;
	}
	concat(other) {
		const ops = this.ops.concat(other.ops);
		const states = applyPatch(this.state, other.ops);
		return new RunLog({
			ops,
			state: states[states.length - 1].newDocument
		});
	}
	static fromRunLogPatch(patch$2) {
		const states = applyPatch({}, patch$2.ops);
		return new RunLog({
			ops: patch$2.ops,
			state: states[states.length - 1].newDocument
		});
	}
};
const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
/**
* Extract standardized inputs from a run.
*
* Standardizes the inputs based on the type of the runnable used.
*
* @param run - Run object
* @param schemaFormat - The schema format to use.
*
* @returns Valid inputs are only dict. By conventions, inputs always represented
* invocation using named arguments.
* A null means that the input is not yet known!
*/
async function _getStandardizedInputs(run, schemaFormat) {
	if (schemaFormat === "original") throw new Error("Do not assign inputs with original schema drop the key for now. When inputs are added to streamLog they should be added with standardized schema for streaming events.");
	const { inputs } = run;
	if ([
		"retriever",
		"llm",
		"prompt"
	].includes(run.run_type)) return inputs;
	if (Object.keys(inputs).length === 1 && inputs?.input === "") return void 0;
	return inputs.input;
}
async function _getStandardizedOutputs(run, schemaFormat) {
	const { outputs } = run;
	if (schemaFormat === "original") return outputs;
	if ([
		"retriever",
		"llm",
		"prompt"
	].includes(run.run_type)) return outputs;
	if (outputs !== void 0 && Object.keys(outputs).length === 1 && outputs?.output !== void 0) return outputs.output;
	return outputs;
}
function isChatGenerationChunk(x) {
	return x !== void 0 && x.message !== void 0;
}
/**
* Class that extends the `BaseTracer` class from the
* `langchain.callbacks.tracers.base` module. It represents a callback
* handler that logs the execution of runs and emits `RunLog` instances to a
* `RunLogStream`.
*/
var LogStreamCallbackHandler = class extends BaseTracer {
	constructor(fields) {
		super({
			_awaitHandler: true,
			...fields
		});
		Object.defineProperty(this, "autoClose", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "includeNames", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "includeTypes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "includeTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeNames", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeTypes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "_schemaFormat", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "original"
		});
		Object.defineProperty(this, "rootId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "keyMapByRunId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: {}
		});
		Object.defineProperty(this, "counterMapByRunName", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: {}
		});
		Object.defineProperty(this, "transformStream", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "writer", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "receiveStream", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "log_stream_tracer"
		});
		Object.defineProperty(this, "lc_prefer_streaming", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		this.autoClose = fields?.autoClose ?? true;
		this.includeNames = fields?.includeNames;
		this.includeTypes = fields?.includeTypes;
		this.includeTags = fields?.includeTags;
		this.excludeNames = fields?.excludeNames;
		this.excludeTypes = fields?.excludeTypes;
		this.excludeTags = fields?.excludeTags;
		this._schemaFormat = fields?._schemaFormat ?? this._schemaFormat;
		this.transformStream = new TransformStream();
		this.writer = this.transformStream.writable.getWriter();
		this.receiveStream = IterableReadableStream.fromReadableStream(this.transformStream.readable);
	}
	[Symbol.asyncIterator]() {
		return this.receiveStream;
	}
	async persistRun(_run) {}
	_includeRun(run) {
		if (run.id === this.rootId) return false;
		const runTags = run.tags ?? [];
		let include = this.includeNames === void 0 && this.includeTags === void 0 && this.includeTypes === void 0;
		if (this.includeNames !== void 0) include = include || this.includeNames.includes(run.name);
		if (this.includeTypes !== void 0) include = include || this.includeTypes.includes(run.run_type);
		if (this.includeTags !== void 0) include = include || runTags.find((tag) => this.includeTags?.includes(tag)) !== void 0;
		if (this.excludeNames !== void 0) include = include && !this.excludeNames.includes(run.name);
		if (this.excludeTypes !== void 0) include = include && !this.excludeTypes.includes(run.run_type);
		if (this.excludeTags !== void 0) include = include && runTags.every((tag) => !this.excludeTags?.includes(tag));
		return include;
	}
	async *tapOutputIterable(runId, output) {
		for await (const chunk of output) {
			if (runId !== this.rootId) {
				const key = this.keyMapByRunId[runId];
				if (key) await this.writer.write(new RunLogPatch({ ops: [{
					op: "add",
					path: `/logs/${key}/streamed_output/-`,
					value: chunk
				}] }));
			}
			yield chunk;
		}
	}
	async onRunCreate(run) {
		if (this.rootId === void 0) {
			this.rootId = run.id;
			await this.writer.write(new RunLogPatch({ ops: [{
				op: "replace",
				path: "",
				value: {
					id: run.id,
					name: run.name,
					type: run.run_type,
					streamed_output: [],
					final_output: void 0,
					logs: {}
				}
			}] }));
		}
		if (!this._includeRun(run)) return;
		if (this.counterMapByRunName[run.name] === void 0) this.counterMapByRunName[run.name] = 0;
		this.counterMapByRunName[run.name] += 1;
		const count = this.counterMapByRunName[run.name];
		this.keyMapByRunId[run.id] = count === 1 ? run.name : `${run.name}:${count}`;
		const logEntry = {
			id: run.id,
			name: run.name,
			type: run.run_type,
			tags: run.tags ?? [],
			metadata: run.extra?.metadata ?? {},
			start_time: new Date(run.start_time).toISOString(),
			streamed_output: [],
			streamed_output_str: [],
			final_output: void 0,
			end_time: void 0
		};
		if (this._schemaFormat === "streaming_events") logEntry.inputs = await _getStandardizedInputs(run, this._schemaFormat);
		await this.writer.write(new RunLogPatch({ ops: [{
			op: "add",
			path: `/logs/${this.keyMapByRunId[run.id]}`,
			value: logEntry
		}] }));
	}
	async onRunUpdate(run) {
		try {
			const runName = this.keyMapByRunId[run.id];
			if (runName === void 0) return;
			const ops = [];
			if (this._schemaFormat === "streaming_events") ops.push({
				op: "replace",
				path: `/logs/${runName}/inputs`,
				value: await _getStandardizedInputs(run, this._schemaFormat)
			});
			ops.push({
				op: "add",
				path: `/logs/${runName}/final_output`,
				value: await _getStandardizedOutputs(run, this._schemaFormat)
			});
			if (run.end_time !== void 0) ops.push({
				op: "add",
				path: `/logs/${runName}/end_time`,
				value: new Date(run.end_time).toISOString()
			});
			const patch$2 = new RunLogPatch({ ops });
			await this.writer.write(patch$2);
		} finally {
			if (run.id === this.rootId) {
				const patch$2 = new RunLogPatch({ ops: [{
					op: "replace",
					path: "/final_output",
					value: await _getStandardizedOutputs(run, this._schemaFormat)
				}] });
				await this.writer.write(patch$2);
				if (this.autoClose) await this.writer.close();
			}
		}
	}
	async onLLMNewToken(run, token, kwargs) {
		const runName = this.keyMapByRunId[run.id];
		if (runName === void 0) return;
		const isChatModel = run.inputs.messages !== void 0;
		let streamedOutputValue;
		if (isChatModel) if (isChatGenerationChunk(kwargs?.chunk)) streamedOutputValue = kwargs?.chunk;
		else streamedOutputValue = new AIMessageChunk({
			id: `run-${run.id}`,
			content: token
		});
		else streamedOutputValue = token;
		const patch$2 = new RunLogPatch({ ops: [{
			op: "add",
			path: `/logs/${runName}/streamed_output_str/-`,
			value: token
		}, {
			op: "add",
			path: `/logs/${runName}/streamed_output/-`,
			value: streamedOutputValue
		}] });
		await this.writer.write(patch$2);
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/outputs.js
var outputs_exports = {};
__export(outputs_exports, {
	ChatGenerationChunk: () => ChatGenerationChunk,
	GenerationChunk: () => GenerationChunk,
	RUN_KEY: () => RUN_KEY
});
const RUN_KEY = "__run";
/**
* Chunk of a single generation. Used for streaming.
*/
var GenerationChunk = class GenerationChunk {
	constructor(fields) {
		Object.defineProperty(this, "text", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "generationInfo", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.text = fields.text;
		this.generationInfo = fields.generationInfo;
	}
	concat(chunk) {
		return new GenerationChunk({
			text: this.text + chunk.text,
			generationInfo: {
				...this.generationInfo,
				...chunk.generationInfo
			}
		});
	}
};
var ChatGenerationChunk = class ChatGenerationChunk extends GenerationChunk {
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "message", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.message = fields.message;
	}
	concat(chunk) {
		return new ChatGenerationChunk({
			text: this.text + chunk.text,
			generationInfo: {
				...this.generationInfo,
				...chunk.generationInfo
			},
			message: this.message.concat(chunk.message)
		});
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tracers/event_stream.js
function assignName({ name, serialized }) {
	if (name !== void 0) return name;
	if (serialized?.name !== void 0) return serialized.name;
	else if (serialized?.id !== void 0 && Array.isArray(serialized?.id)) return serialized.id[serialized.id.length - 1];
	return "Unnamed";
}
const isStreamEventsHandler = (handler) => handler.name === "event_stream_tracer";
/**
* Class that extends the `BaseTracer` class from the
* `langchain.callbacks.tracers.base` module. It represents a callback
* handler that logs the execution of runs and emits `RunLog` instances to a
* `RunLogStream`.
*/
var EventStreamCallbackHandler = class extends BaseTracer {
	constructor(fields) {
		super({
			_awaitHandler: true,
			...fields
		});
		Object.defineProperty(this, "autoClose", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "includeNames", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "includeTypes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "includeTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeNames", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeTypes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "runInfoMap", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: /* @__PURE__ */ new Map()
		});
		Object.defineProperty(this, "tappedPromises", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: /* @__PURE__ */ new Map()
		});
		Object.defineProperty(this, "transformStream", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "writer", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "receiveStream", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "event_stream_tracer"
		});
		Object.defineProperty(this, "lc_prefer_streaming", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		this.autoClose = fields?.autoClose ?? true;
		this.includeNames = fields?.includeNames;
		this.includeTypes = fields?.includeTypes;
		this.includeTags = fields?.includeTags;
		this.excludeNames = fields?.excludeNames;
		this.excludeTypes = fields?.excludeTypes;
		this.excludeTags = fields?.excludeTags;
		this.transformStream = new TransformStream();
		this.writer = this.transformStream.writable.getWriter();
		this.receiveStream = IterableReadableStream.fromReadableStream(this.transformStream.readable);
	}
	[Symbol.asyncIterator]() {
		return this.receiveStream;
	}
	async persistRun(_run) {}
	_includeRun(run) {
		const runTags = run.tags ?? [];
		let include = this.includeNames === void 0 && this.includeTags === void 0 && this.includeTypes === void 0;
		if (this.includeNames !== void 0) include = include || this.includeNames.includes(run.name);
		if (this.includeTypes !== void 0) include = include || this.includeTypes.includes(run.runType);
		if (this.includeTags !== void 0) include = include || runTags.find((tag) => this.includeTags?.includes(tag)) !== void 0;
		if (this.excludeNames !== void 0) include = include && !this.excludeNames.includes(run.name);
		if (this.excludeTypes !== void 0) include = include && !this.excludeTypes.includes(run.runType);
		if (this.excludeTags !== void 0) include = include && runTags.every((tag) => !this.excludeTags?.includes(tag));
		return include;
	}
	async *tapOutputIterable(runId, outputStream) {
		const firstChunk = await outputStream.next();
		if (firstChunk.done) return;
		const runInfo = this.runInfoMap.get(runId);
		if (runInfo === void 0) {
			yield firstChunk.value;
			return;
		}
		function _formatOutputChunk(eventType, data) {
			if (eventType === "llm" && typeof data === "string") return new GenerationChunk({ text: data });
			return data;
		}
		let tappedPromise = this.tappedPromises.get(runId);
		if (tappedPromise === void 0) {
			let tappedPromiseResolver;
			tappedPromise = new Promise((resolve) => {
				tappedPromiseResolver = resolve;
			});
			this.tappedPromises.set(runId, tappedPromise);
			try {
				const event = {
					event: `on_${runInfo.runType}_stream`,
					run_id: runId,
					name: runInfo.name,
					tags: runInfo.tags,
					metadata: runInfo.metadata,
					data: {}
				};
				await this.send({
					...event,
					data: { chunk: _formatOutputChunk(runInfo.runType, firstChunk.value) }
				}, runInfo);
				yield firstChunk.value;
				for await (const chunk of outputStream) {
					if (runInfo.runType !== "tool" && runInfo.runType !== "retriever") await this.send({
						...event,
						data: { chunk: _formatOutputChunk(runInfo.runType, chunk) }
					}, runInfo);
					yield chunk;
				}
			} finally {
				tappedPromiseResolver();
			}
		} else {
			yield firstChunk.value;
			for await (const chunk of outputStream) yield chunk;
		}
	}
	async send(payload, run) {
		if (this._includeRun(run)) await this.writer.write(payload);
	}
	async sendEndEvent(payload, run) {
		const tappedPromise = this.tappedPromises.get(payload.run_id);
		if (tappedPromise !== void 0) tappedPromise.then(() => {
			this.send(payload, run);
		});
		else await this.send(payload, run);
	}
	async onLLMStart(run) {
		const runName = assignName(run);
		const runType = run.inputs.messages !== void 0 ? "chat_model" : "llm";
		const runInfo = {
			tags: run.tags ?? [],
			metadata: run.extra?.metadata ?? {},
			name: runName,
			runType,
			inputs: run.inputs
		};
		this.runInfoMap.set(run.id, runInfo);
		const eventName = `on_${runType}_start`;
		await this.send({
			event: eventName,
			data: { input: run.inputs },
			name: runName,
			tags: run.tags ?? [],
			run_id: run.id,
			metadata: run.extra?.metadata ?? {}
		}, runInfo);
	}
	async onLLMNewToken(run, token, kwargs) {
		const runInfo = this.runInfoMap.get(run.id);
		let chunk;
		let eventName;
		if (runInfo === void 0) throw new Error(`onLLMNewToken: Run ID ${run.id} not found in run map.`);
		if (this.runInfoMap.size === 1) return;
		if (runInfo.runType === "chat_model") {
			eventName = "on_chat_model_stream";
			if (kwargs?.chunk === void 0) chunk = new AIMessageChunk({
				content: token,
				id: `run-${run.id}`
			});
			else chunk = kwargs.chunk.message;
		} else if (runInfo.runType === "llm") {
			eventName = "on_llm_stream";
			if (kwargs?.chunk === void 0) chunk = new GenerationChunk({ text: token });
			else chunk = kwargs.chunk;
		} else throw new Error(`Unexpected run type ${runInfo.runType}`);
		await this.send({
			event: eventName,
			data: { chunk },
			run_id: run.id,
			name: runInfo.name,
			tags: runInfo.tags,
			metadata: runInfo.metadata
		}, runInfo);
	}
	async onLLMEnd(run) {
		const runInfo = this.runInfoMap.get(run.id);
		this.runInfoMap.delete(run.id);
		let eventName;
		if (runInfo === void 0) throw new Error(`onLLMEnd: Run ID ${run.id} not found in run map.`);
		const generations = run.outputs?.generations;
		let output;
		if (runInfo.runType === "chat_model") {
			for (const generation of generations ?? []) {
				if (output !== void 0) break;
				output = generation[0]?.message;
			}
			eventName = "on_chat_model_end";
		} else if (runInfo.runType === "llm") {
			output = {
				generations: generations?.map((generation) => {
					return generation.map((chunk) => {
						return {
							text: chunk.text,
							generationInfo: chunk.generationInfo
						};
					});
				}),
				llmOutput: run.outputs?.llmOutput ?? {}
			};
			eventName = "on_llm_end";
		} else throw new Error(`onLLMEnd: Unexpected run type: ${runInfo.runType}`);
		await this.sendEndEvent({
			event: eventName,
			data: {
				output,
				input: runInfo.inputs
			},
			run_id: run.id,
			name: runInfo.name,
			tags: runInfo.tags,
			metadata: runInfo.metadata
		}, runInfo);
	}
	async onChainStart(run) {
		const runName = assignName(run);
		const runType = run.run_type ?? "chain";
		const runInfo = {
			tags: run.tags ?? [],
			metadata: run.extra?.metadata ?? {},
			name: runName,
			runType: run.run_type
		};
		let eventData = {};
		if (run.inputs.input === "" && Object.keys(run.inputs).length === 1) {
			eventData = {};
			runInfo.inputs = {};
		} else if (run.inputs.input !== void 0) {
			eventData.input = run.inputs.input;
			runInfo.inputs = run.inputs.input;
		} else {
			eventData.input = run.inputs;
			runInfo.inputs = run.inputs;
		}
		this.runInfoMap.set(run.id, runInfo);
		await this.send({
			event: `on_${runType}_start`,
			data: eventData,
			name: runName,
			tags: run.tags ?? [],
			run_id: run.id,
			metadata: run.extra?.metadata ?? {}
		}, runInfo);
	}
	async onChainEnd(run) {
		const runInfo = this.runInfoMap.get(run.id);
		this.runInfoMap.delete(run.id);
		if (runInfo === void 0) throw new Error(`onChainEnd: Run ID ${run.id} not found in run map.`);
		const eventName = `on_${run.run_type}_end`;
		const inputs = run.inputs ?? runInfo.inputs ?? {};
		const outputs = run.outputs?.output ?? run.outputs;
		const data = {
			output: outputs,
			input: inputs
		};
		if (inputs.input && Object.keys(inputs).length === 1) {
			data.input = inputs.input;
			runInfo.inputs = inputs.input;
		}
		await this.sendEndEvent({
			event: eventName,
			data,
			run_id: run.id,
			name: runInfo.name,
			tags: runInfo.tags,
			metadata: runInfo.metadata ?? {}
		}, runInfo);
	}
	async onToolStart(run) {
		const runName = assignName(run);
		const runInfo = {
			tags: run.tags ?? [],
			metadata: run.extra?.metadata ?? {},
			name: runName,
			runType: "tool",
			inputs: run.inputs ?? {}
		};
		this.runInfoMap.set(run.id, runInfo);
		await this.send({
			event: "on_tool_start",
			data: { input: run.inputs ?? {} },
			name: runName,
			run_id: run.id,
			tags: run.tags ?? [],
			metadata: run.extra?.metadata ?? {}
		}, runInfo);
	}
	async onToolEnd(run) {
		const runInfo = this.runInfoMap.get(run.id);
		this.runInfoMap.delete(run.id);
		if (runInfo === void 0) throw new Error(`onToolEnd: Run ID ${run.id} not found in run map.`);
		if (runInfo.inputs === void 0) throw new Error(`onToolEnd: Run ID ${run.id} is a tool call, and is expected to have traced inputs.`);
		const output = run.outputs?.output === void 0 ? run.outputs : run.outputs.output;
		await this.sendEndEvent({
			event: "on_tool_end",
			data: {
				output,
				input: runInfo.inputs
			},
			run_id: run.id,
			name: runInfo.name,
			tags: runInfo.tags,
			metadata: runInfo.metadata
		}, runInfo);
	}
	async onRetrieverStart(run) {
		const runName = assignName(run);
		const runType = "retriever";
		const runInfo = {
			tags: run.tags ?? [],
			metadata: run.extra?.metadata ?? {},
			name: runName,
			runType,
			inputs: { query: run.inputs.query }
		};
		this.runInfoMap.set(run.id, runInfo);
		await this.send({
			event: "on_retriever_start",
			data: { input: { query: run.inputs.query } },
			name: runName,
			tags: run.tags ?? [],
			run_id: run.id,
			metadata: run.extra?.metadata ?? {}
		}, runInfo);
	}
	async onRetrieverEnd(run) {
		const runInfo = this.runInfoMap.get(run.id);
		this.runInfoMap.delete(run.id);
		if (runInfo === void 0) throw new Error(`onRetrieverEnd: Run ID ${run.id} not found in run map.`);
		await this.sendEndEvent({
			event: "on_retriever_end",
			data: {
				output: run.outputs?.documents ?? run.outputs,
				input: runInfo.inputs
			},
			run_id: run.id,
			name: runInfo.name,
			tags: runInfo.tags,
			metadata: runInfo.metadata
		}, runInfo);
	}
	async handleCustomEvent(eventName, data, runId) {
		const runInfo = this.runInfoMap.get(runId);
		if (runInfo === void 0) throw new Error(`handleCustomEvent: Run ID ${runId} not found in run map.`);
		await this.send({
			event: "on_custom_event",
			run_id: runId,
			name: eventName,
			tags: runInfo.tags,
			metadata: runInfo.metadata,
			data
		}, runInfo);
	}
	async finish() {
		const pendingPromises = [...this.tappedPromises.values()];
		Promise.all(pendingPromises).finally(() => {
			this.writer.close();
		});
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/utils/async_caller.js
var async_caller_exports = {};
__export(async_caller_exports, { AsyncCaller: () => AsyncCaller });
var import_p_retry$1 = __toESM(require_p_retry(), 1);
var import_dist = __toESM(require_dist(), 1);
const STATUS_NO_RETRY = [
	400,
	401,
	402,
	403,
	404,
	405,
	406,
	407,
	409
];
const defaultFailedAttemptHandler = (error) => {
	if (error.message.startsWith("Cancel") || error.message.startsWith("AbortError") || error.name === "AbortError") throw error;
	if (error?.code === "ECONNABORTED") throw error;
	const status = error?.response?.status ?? error?.status;
	if (status && STATUS_NO_RETRY.includes(+status)) throw error;
	if (error?.error?.code === "insufficient_quota") {
		const err = new Error(error?.message);
		err.name = "InsufficientQuotaError";
		throw err;
	}
};
/**
* A class that can be used to make async calls with concurrency and retry logic.
*
* This is useful for making calls to any kind of "expensive" external resource,
* be it because it's rate-limited, subject to network issues, etc.
*
* Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
* to `Infinity`. This means that by default, all calls will be made in parallel.
*
* Retries are limited by the `maxRetries` parameter, which defaults to 6. This
* means that by default, each call will be retried up to 6 times, with an
* exponential backoff between each attempt.
*/
var AsyncCaller = class {
	constructor(params) {
		Object.defineProperty(this, "maxConcurrency", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "maxRetries", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "onFailedAttempt", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "queue", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.maxConcurrency = params.maxConcurrency ?? Infinity;
		this.maxRetries = params.maxRetries ?? 6;
		this.onFailedAttempt = params.onFailedAttempt ?? defaultFailedAttemptHandler;
		const PQueue$1 = "default" in import_dist.default ? import_dist.default.default : import_dist.default;
		this.queue = new PQueue$1({ concurrency: this.maxConcurrency });
	}
	call(callable, ...args) {
		return this.queue.add(() => (0, import_p_retry$1.default)(() => callable(...args).catch((error) => {
			if (error instanceof Error) throw error;
			else throw new Error(error);
		}), {
			onFailedAttempt: this.onFailedAttempt,
			retries: this.maxRetries,
			randomize: true
		}), { throwOnTimeout: true });
	}
	callWithOptions(options, callable, ...args) {
		if (options.signal) return Promise.race([this.call(callable, ...args), new Promise((_, reject) => {
			options.signal?.addEventListener("abort", () => {
				reject(new Error("AbortError"));
			});
		})]);
		return this.call(callable, ...args);
	}
	fetch(...args) {
		return this.call(() => fetch(...args).then((res) => res.ok ? res : Promise.reject(res)));
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/tracers/root_listener.js
var RootListenersTracer = class extends BaseTracer {
	constructor({ config, onStart, onEnd, onError }) {
		super({ _awaitHandler: true });
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "RootListenersTracer"
		});
		/** The Run's ID. Type UUID */
		Object.defineProperty(this, "rootId", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "config", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "argOnStart", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "argOnEnd", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "argOnError", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.config = config;
		this.argOnStart = onStart;
		this.argOnEnd = onEnd;
		this.argOnError = onError;
	}
	/**
	* This is a legacy method only called once for an entire run tree
	* therefore not useful here
	* @param {Run} _ Not used
	*/
	persistRun(_) {
		return Promise.resolve();
	}
	async onRunCreate(run) {
		if (this.rootId) return;
		this.rootId = run.id;
		if (this.argOnStart) await this.argOnStart(run, this.config);
	}
	async onRunUpdate(run) {
		if (run.id !== this.rootId) return;
		if (!run.error) {
			if (this.argOnEnd) await this.argOnEnd(run, this.config);
		} else if (this.argOnError) await this.argOnError(run, this.config);
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/utils.js
function isRunnableInterface(thing) {
	return thing ? thing.lc_runnable : false;
}
/**
* Utility to filter the root event in the streamEvents implementation.
* This is simply binding the arguments to the namespace to make save on
* a bit of typing in the streamEvents implementation.
*
* TODO: Refactor and remove.
*/
var _RootEventFilter = class {
	constructor(fields) {
		Object.defineProperty(this, "includeNames", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "includeTypes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "includeTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeNames", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeTypes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "excludeTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.includeNames = fields.includeNames;
		this.includeTypes = fields.includeTypes;
		this.includeTags = fields.includeTags;
		this.excludeNames = fields.excludeNames;
		this.excludeTypes = fields.excludeTypes;
		this.excludeTags = fields.excludeTags;
	}
	includeEvent(event, rootType) {
		let include = this.includeNames === void 0 && this.includeTypes === void 0 && this.includeTags === void 0;
		const eventTags = event.tags ?? [];
		if (this.includeNames !== void 0) include = include || this.includeNames.includes(event.name);
		if (this.includeTypes !== void 0) include = include || this.includeTypes.includes(rootType);
		if (this.includeTags !== void 0) include = include || eventTags.some((tag) => this.includeTags?.includes(tag));
		if (this.excludeNames !== void 0) include = include && !this.excludeNames.includes(event.name);
		if (this.excludeTypes !== void 0) include = include && !this.excludeTypes.includes(rootType);
		if (this.excludeTags !== void 0) include = include && eventTags.every((tag) => !this.excludeTags?.includes(tag));
		return include;
	}
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/Options.js
const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
const 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",
	target: "jsonSchema7",
	strictUnions: false,
	definitions: {},
	errorMessages: false,
	markdownDescription: false,
	patternStrategy: "escape",
	applyRegexFlags: false,
	emailStrategy: "format:email",
	base64Strategy: "contentEncoding:base64",
	nameStrategy: "ref"
};
const getDefaultOptions = (options) => typeof options === "string" ? {
	...defaultOptions,
	name: options
} : {
	...defaultOptions,
	...options
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/Refs.js
const 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
			],
			jsonSchema: void 0
		}]))
	};
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
function addErrorMessage(res, key, errorMessage, refs) {
	if (!refs?.errorMessages) return;
	if (errorMessage) res.errorMessage = {
		...res.errorMessage,
		[key]: errorMessage
	};
}
function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
	res[key] = value;
	addErrorMessage(res, key, errorMessage, refs);
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
function parseAnyDef() {
	return {};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
function parseArrayDef(def, refs) {
	const res = { type: "array" };
	if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) res.items = parseDef(def.type._def, {
		...refs,
		currentPath: [...refs.currentPath, "items"]
	});
	if (def.minLength) setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
	if (def.maxLength) setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
	if (def.exactLength) {
		setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
		setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
	}
	return res;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
function parseBigintDef(def, refs) {
	const res = {
		type: "integer",
		format: "int64"
	};
	if (!def.checks) return res;
	for (const check of def.checks) switch (check.kind) {
		case "min":
			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
			else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
			else {
				if (!check.inclusive) res.exclusiveMinimum = true;
				setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
			}
			break;
		case "max":
			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
			else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
			else {
				if (!check.inclusive) res.exclusiveMaximum = true;
				setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
			}
			break;
		case "multipleOf":
			setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
			break;
	}
	return res;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
function parseBooleanDef() {
	return { type: "boolean" };
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
function parseBrandedDef(_def, refs) {
	return parseDef(_def.type._def, refs);
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
const parseCatchDef = (def, refs) => {
	return parseDef(def.innerType._def, refs);
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
function parseDateDef(def, refs, overrideDateStrategy) {
	const strategy = 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, refs);
	}
}
const integerDateParser = (def, refs) => {
	const res = {
		type: "integer",
		format: "unix-time"
	};
	if (refs.target === "openApi3") return res;
	for (const check of def.checks) switch (check.kind) {
		case "min":
			setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
			break;
		case "max":
			setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
			break;
	}
	return res;
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
function parseDefaultDef(_def, refs) {
	return {
		...parseDef(_def.innerType._def, refs),
		default: _def.defaultValue()
	};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
function parseEffectsDef(_def, refs) {
	return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
function parseEnumDef(def) {
	return {
		type: "string",
		enum: Array.from(def.values)
	};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
const 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);
	let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
	const mergedAllOf = [];
	allOf.forEach((schema) => {
		if (isJsonSchema7AllOfType(schema)) {
			mergedAllOf.push(...schema.allOf);
			if (schema.unevaluatedProperties === void 0) unevaluatedProperties = void 0;
		} else {
			let nestedSchema = schema;
			if ("additionalProperties" in schema && schema.additionalProperties === false) {
				const { additionalProperties,...rest } = schema;
				nestedSchema = rest;
			} else unevaluatedProperties = void 0;
			mergedAllOf.push(nestedSchema);
		}
	});
	return mergedAllOf.length ? {
		allOf: mergedAllOf,
		...unevaluatedProperties
	} : void 0;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
function parseLiteralDef(def, refs) {
	const parsedType = typeof def.value;
	if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") return { type: Array.isArray(def.value) ? "array" : "object" };
	if (refs.target === "openApi3") return {
		type: parsedType === "bigint" ? "integer" : parsedType,
		enum: [def.value]
	};
	return {
		type: parsedType === "bigint" ? "integer" : parsedType,
		const: def.value
	};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
let emojiRegex = void 0;
/**
* Generated from the regular expressions found here as of 2024-05-22:
* https://github.com/colinhacks/zod/blob/master/src/types.ts.
*
* Expressions with /i flag have been changed accordingly.
*/
const zodPatterns = {
	cuid: /^[cC][^\s-]{8,}$/,
	cuid2: /^[0-9a-z]+$/,
	ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
	email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
	emoji: () => {
		if (emojiRegex === void 0) emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
		return emojiRegex;
	},
	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}$/,
	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])$/,
	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":
			setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
			break;
		case "max":
			setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
			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":
			setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
			setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
			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": {
					setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
					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:
 /* c8 ignore next */
		((_) => {})(check);
	}
	return res;
}
function escapeLiteralCheckValue(literal, refs) {
	return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
}
const 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) {
	if (schema.format || schema.anyOf?.some((x) => x.format)) {
		if (!schema.anyOf) schema.anyOf = [];
		if (schema.format) {
			schema.anyOf.push({
				format: schema.format,
				...schema.errorMessage && refs.errorMessages && { errorMessage: { format: schema.errorMessage.format } }
			});
			delete schema.format;
			if (schema.errorMessage) {
				delete schema.errorMessage.format;
				if (Object.keys(schema.errorMessage).length === 0) delete schema.errorMessage;
			}
		}
		schema.anyOf.push({
			format: value,
			...message && refs.errorMessages && { errorMessage: { format: message } }
		});
	} else setResponseValueAndErrors(schema, "format", value, message, refs);
}
function addPattern(schema, regex, message, refs) {
	if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
		if (!schema.allOf) schema.allOf = [];
		if (schema.pattern) {
			schema.allOf.push({
				pattern: schema.pattern,
				...schema.errorMessage && refs.errorMessages && { errorMessage: { pattern: schema.errorMessage.pattern } }
			});
			delete schema.pattern;
			if (schema.errorMessage) {
				delete schema.errorMessage.pattern;
				if (Object.keys(schema.errorMessage).length === 0) delete schema.errorMessage;
			}
		}
		schema.allOf.push({
			pattern: stringifyRegExpWithFlags(regex, refs),
			...message && refs.errorMessages && { errorMessage: { pattern: message } }
		});
	} else setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
}
function stringifyRegExpWithFlags(regex, refs) {
	if (!refs.applyRegexFlags || !regex.flags) return regex.source;
	const flags = {
		i: regex.flags.includes("i"),
		m: regex.flags.includes("m"),
		s: regex.flags.includes("s")
	};
	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] === "-" && source[i + 2]?.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\n]))`;
				continue;
			} else if (source[i] === "$") {
				pattern += `($|(?=[\r\n]))`;
				continue;
			}
		}
		if (flags.s && source[i] === ".") {
			pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
			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 {
		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;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
function parseRecordDef(def, refs) {
	if (refs.target === "openAi") console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
	if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) return {
		type: "object",
		required: def.keyType._def.values,
		properties: def.keyType._def.values.reduce((acc, key) => ({
			...acc,
			[key]: parseDef(def.valueType._def, {
				...refs,
				currentPath: [
					...refs.currentPath,
					"properties",
					key
				]
			}) ?? {}
		}), {}),
		additionalProperties: refs.rejectedAdditionalProperties
	};
	const schema = {
		type: "object",
		additionalProperties: parseDef(def.valueType._def, {
			...refs,
			currentPath: [...refs.currentPath, "additionalProperties"]
		}) ?? refs.allowedAdditionalProperties
	};
	if (refs.target === "openApi3") return schema;
	if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
		const { type,...keyType } = parseStringDef(def.keyType._def, refs);
		return {
			...schema,
			propertyNames: keyType
		};
	} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) return {
		...schema,
		propertyNames: { enum: def.keyType._def.values }
	};
	else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
		const { type,...keyType } = parseBrandedDef(def.keyType._def, refs);
		return {
			...schema,
			propertyNames: keyType
		};
	}
	return schema;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
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"
		]
	}) || {};
	const values = parseDef(def.valueType._def, {
		...refs,
		currentPath: [
			...refs.currentPath,
			"items",
			"items",
			"1"
		]
	}) || {};
	return {
		type: "array",
		maxItems: 125,
		items: {
			type: "array",
			items: [keys, values],
			minItems: 2,
			maxItems: 2
		}
	};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
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
	};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
function parseNeverDef() {
	return { not: {} };
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
function parseNullDef(refs) {
	return refs.target === "openApi3" ? {
		enum: ["null"],
		nullable: true
	} : { type: "null" };
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
const primitiveMappings = {
	ZodString: "string",
	ZodNumber: "number",
	ZodBigInt: "integer",
	ZodBoolean: "boolean",
	ZodNull: "null"
};
function parseUnionDef(def, refs) {
	if (refs.target === "openApi3") return asAnyOf(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((types$1, x) => {
			const type = primitiveMappings[x._def.typeName];
			return type && !types$1.includes(type) ? [...types$1, type] : types$1;
		}, []);
		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((x$1) => !acc.includes(x$1))], [])
	};
	return asAnyOf(def, refs);
}
const 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;
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
function parseNullableDef(def, refs) {
	if ([
		"ZodString",
		"ZodNumber",
		"ZodBigInt",
		"ZodBoolean",
		"ZodNull"
	].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
		if (refs.target === "openApi3") return {
			type: primitiveMappings[def.innerType._def.typeName],
			nullable: true
		};
		return { type: [primitiveMappings[def.innerType._def.typeName], "null"] };
	}
	if (refs.target === "openApi3") {
		const base$1 = parseDef(def.innerType._def, {
			...refs,
			currentPath: [...refs.currentPath]
		});
		if (base$1 && "$ref" in base$1) return {
			allOf: [base$1],
			nullable: true
		};
		return base$1 && {
			...base$1,
			nullable: true
		};
	}
	const base = parseDef(def.innerType._def, {
		...refs,
		currentPath: [
			...refs.currentPath,
			"anyOf",
			"0"
		]
	});
	return base && { anyOf: [base, { type: "null" }] };
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
function parseNumberDef(def, refs) {
	const res = { type: "number" };
	if (!def.checks) return res;
	for (const check of def.checks) switch (check.kind) {
		case "int":
			res.type = "integer";
			addErrorMessage(res, "type", check.message, refs);
			break;
		case "min":
			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
			else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
			else {
				if (!check.inclusive) res.exclusiveMinimum = true;
				setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
			}
			break;
		case "max":
			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
			else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
			else {
				if (!check.inclusive) res.exclusiveMaximum = true;
				setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
			}
			break;
		case "multipleOf":
			setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
			break;
	}
	return res;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
function parseObjectDef(def, refs) {
	const forceOptionalIntoNullable = refs.target === "openAi";
	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;
		let propOptional = safeIsOptional(propDef);
		if (propOptional && forceOptionalIntoNullable) {
			if (propDef instanceof ZodOptional) propDef = propDef._def.innerType;
			if (!propDef.isNullable()) propDef = propDef.nullable();
			propOptional = false;
		}
		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 {
		return true;
	}
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
const parseOptionalDef = (def, refs) => {
	if (refs.currentPath.toString() === refs.propertyPath?.toString()) return parseDef(def.innerType._def, refs);
	const innerSchema = parseDef(def.innerType._def, {
		...refs,
		currentPath: [
			...refs.currentPath,
			"anyOf",
			"1"
		]
	});
	return innerSchema ? { anyOf: [{ not: {} }, innerSchema] } : {};
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
const 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) };
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
function parsePromiseDef(def, refs) {
	return parseDef(def.type._def, refs);
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
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) setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
	if (def.maxSize) setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
	return schema;
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
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], [])
	};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
function parseUndefinedDef() {
	return { not: {} };
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
function parseUnknownDef() {
	return {};
}

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
const parseReadonlyDef = (def, refs) => {
	return parseDef(def.innerType._def, refs);
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/selectParser.js
const selectParser = (def, typeName, refs) => {
	switch (typeName) {
		case ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
		case ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def, refs);
		case ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
		case ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def, refs);
		case ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
		case ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
		case ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef();
		case ZodFirstPartyTypeKind.ZodNull: return parseNullDef(refs);
		case ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
		case ZodFirstPartyTypeKind.ZodUnion:
		case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
		case ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
		case ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
		case ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
		case ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def, refs);
		case ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
		case ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
		case ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
		case ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
		case ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
		case ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
		case ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
		case ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
		case ZodFirstPartyTypeKind.ZodNaN:
		case ZodFirstPartyTypeKind.ZodNever: return parseNeverDef();
		case ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
		case ZodFirstPartyTypeKind.ZodAny: return parseAnyDef();
		case ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef();
		case ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
		case ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
		case ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
		case ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
		case ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
		case ZodFirstPartyTypeKind.ZodFunction:
		case ZodFirstPartyTypeKind.ZodVoid:
		case ZodFirstPartyTypeKind.ZodSymbol: return void 0;
		default:
 /* c8 ignore next */
		return ((_) => void 0)(typeName);
	}
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/parseDef.js
function parseDef(def, refs, forceResolution = false) {
	const seenItem = refs.seen.get(def);
	if (refs.override) {
		const overrideResult = refs.override?.(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 jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
	if (jsonSchema) addMeta(def, refs, jsonSchema);
	if (refs.postProcess) {
		const postProcessResult = refs.postProcess(jsonSchema, def, refs);
		newItem.jsonSchema = jsonSchema;
		return postProcessResult;
	}
	newItem.jsonSchema = jsonSchema;
	return jsonSchema;
}
const 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 {};
			}
			return refs.$refStrategy === "seen" ? {} : void 0;
		}
	}
};
const 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("/");
};
const addMeta = (def, refs, jsonSchema) => {
	if (def.description) {
		jsonSchema.description = def.description;
		if (refs.markdownDescription) jsonSchema.markdownDescription = def.description;
	}
	return jsonSchema;
};

//#endregion
//#region node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.57/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
const zodToJsonSchema = (schema, options) => {
	const refs = getRefs(options);
	const definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name$1, schema$1]) => ({
		...acc,
		[name$1]: parseDef(schema$1._def, {
			...refs,
			currentPath: [
				...refs.basePath,
				refs.definitionPath,
				name$1
			]
		}, true) ?? {}
	}), {}) : void 0;
	const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
	const main = parseDef(schema._def, name === void 0 ? refs : {
		...refs,
		currentPath: [
			...refs.basePath,
			refs.definitionPath,
			name
		]
	}, false) ?? {};
	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
		}
	};
	if (refs.target === "jsonSchema7") combined.$schema = "http://json-schema.org/draft-07/schema#";
	else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
	if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
	return combined;
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/graph_mermaid.js
function _escapeNodeLabel(nodeLabel) {
	return nodeLabel.replace(/[^a-zA-Z-_0-9]/g, "_");
}
const MARKDOWN_SPECIAL_CHARS = [
	"*",
	"_",
	"`"
];
function _generateMermaidGraphStyles(nodeColors) {
	let styles$1 = "";
	for (const [className, color$1] of Object.entries(nodeColors)) styles$1 += `\tclassDef ${className} ${color$1};\n`;
	return styles$1;
}
/**
* Draws a Mermaid graph using the provided graph data
*/
function drawMermaid(nodes, edges, config) {
	const { firstNode, lastNode, nodeColors, withStyles = true, curveStyle = "linear", wrapLabelNWords = 9 } = config ?? {};
	let mermaidGraph = withStyles ? `%%{init: {'flowchart': {'curve': '${curveStyle}'}}}%%\ngraph TD;\n` : "graph TD;\n";
	if (withStyles) {
		const defaultClassLabel = "default";
		const formatDict = { [defaultClassLabel]: "{0}({1})" };
		if (firstNode !== void 0) formatDict[firstNode] = "{0}([{1}]):::first";
		if (lastNode !== void 0) formatDict[lastNode] = "{0}([{1}]):::last";
		for (const [key, node] of Object.entries(nodes)) {
			const nodeName = node.name.split(":").pop() ?? "";
			const label = MARKDOWN_SPECIAL_CHARS.some((char) => nodeName.startsWith(char) && nodeName.endsWith(char)) ? `<p>${nodeName}</p>` : nodeName;
			let finalLabel = label;
			if (Object.keys(node.metadata ?? {}).length) finalLabel += `<hr/><small><em>${Object.entries(node.metadata ?? {}).map(([k, v]) => `${k} = ${v}`).join("\n")}</em></small>`;
			const nodeLabel = (formatDict[key] ?? formatDict[defaultClassLabel]).replace("{0}", _escapeNodeLabel(key)).replace("{1}", finalLabel);
			mermaidGraph += `\t${nodeLabel}\n`;
		}
	}
	const edgeGroups = {};
	for (const edge of edges) {
		const srcParts = edge.source.split(":");
		const tgtParts = edge.target.split(":");
		const commonPrefix = srcParts.filter((src$1, i) => src$1 === tgtParts[i]).join(":");
		if (!edgeGroups[commonPrefix]) edgeGroups[commonPrefix] = [];
		edgeGroups[commonPrefix].push(edge);
	}
	const seenSubgraphs = /* @__PURE__ */ new Set();
	function addSubgraph(edges$1, prefix$1) {
		const selfLoop = edges$1.length === 1 && edges$1[0].source === edges$1[0].target;
		if (prefix$1 && !selfLoop) {
			const subgraph = prefix$1.split(":").pop();
			if (seenSubgraphs.has(subgraph)) throw new Error(`Found duplicate subgraph '${subgraph}' -- this likely means that you're reusing a subgraph node with the same name. Please adjust your graph to have subgraph nodes with unique names.`);
			seenSubgraphs.add(subgraph);
			mermaidGraph += `\tsubgraph ${subgraph}\n`;
		}
		for (const edge of edges$1) {
			const { source, target, data, conditional } = edge;
			let edgeLabel = "";
			if (data !== void 0) {
				let edgeData = data;
				const words = edgeData.split(" ");
				if (words.length > wrapLabelNWords) edgeData = Array.from({ length: Math.ceil(words.length / wrapLabelNWords) }, (_, i) => words.slice(i * wrapLabelNWords, (i + 1) * wrapLabelNWords).join(" ")).join("&nbsp;<br>&nbsp;");
				edgeLabel = conditional ? ` -. &nbsp;${edgeData}&nbsp; .-> ` : ` -- &nbsp;${edgeData}&nbsp; --> `;
			} else edgeLabel = conditional ? " -.-> " : " --> ";
			mermaidGraph += `\t${_escapeNodeLabel(source)}${edgeLabel}${_escapeNodeLabel(target)};\n`;
		}
		for (const nestedPrefix in edgeGroups) if (nestedPrefix.startsWith(`${prefix$1}:`) && nestedPrefix !== prefix$1) addSubgraph(edgeGroups[nestedPrefix], nestedPrefix);
		if (prefix$1 && !selfLoop) mermaidGraph += "	end\n";
	}
	addSubgraph(edgeGroups[""] ?? [], "");
	for (const prefix$1 in edgeGroups) if (!prefix$1.includes(":") && prefix$1 !== "") addSubgraph(edgeGroups[prefix$1], prefix$1);
	if (withStyles) mermaidGraph += _generateMermaidGraphStyles(nodeColors ?? {});
	return mermaidGraph;
}
/**
* Renders Mermaid graph using the Mermaid.INK API.
*/
async function drawMermaidPng(mermaidSyntax, config) {
	let { backgroundColor = "white" } = config ?? {};
	const mermaidSyntaxEncoded = btoa(mermaidSyntax);
	if (backgroundColor !== void 0) {
		const hexColorPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
		if (!hexColorPattern.test(backgroundColor)) backgroundColor = `!${backgroundColor}`;
	}
	const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}`;
	const res = await fetch(imageUrl);
	if (!res.ok) throw new Error([
		`Failed to render the graph using the Mermaid.INK API.`,
		`Status code: ${res.status}`,
		`Status text: ${res.statusText}`
	].join("\n"));
	const content = await res.blob();
	return content;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/graph.js
function nodeDataStr(id, data) {
	if (id !== void 0 && !validate_default(id)) return id;
	else if (isRunnableInterface(data)) try {
		let dataStr = data.getName();
		dataStr = dataStr.startsWith("Runnable") ? dataStr.slice(8) : dataStr;
		return dataStr;
	} catch (error) {
		return data.getName();
	}
	else return data.name ?? "UnknownSchema";
}
function nodeDataJson(node) {
	if (isRunnableInterface(node.data)) return {
		type: "runnable",
		data: {
			id: node.data.lc_id,
			name: node.data.getName()
		}
	};
	else return {
		type: "schema",
		data: {
			...zodToJsonSchema(node.data.schema),
			title: node.data.name
		}
	};
}
var Graph = class Graph {
	constructor(params) {
		Object.defineProperty(this, "nodes", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: {}
		});
		Object.defineProperty(this, "edges", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		this.nodes = params?.nodes ?? this.nodes;
		this.edges = params?.edges ?? this.edges;
	}
	toJSON() {
		const stableNodeIds = {};
		Object.values(this.nodes).forEach((node, i) => {
			stableNodeIds[node.id] = validate_default(node.id) ? i : node.id;
		});
		return {
			nodes: Object.values(this.nodes).map((node) => ({
				id: stableNodeIds[node.id],
				...nodeDataJson(node)
			})),
			edges: this.edges.map((edge) => {
				const item = {
					source: stableNodeIds[edge.source],
					target: stableNodeIds[edge.target]
				};
				if (typeof edge.data !== "undefined") item.data = edge.data;
				if (typeof edge.conditional !== "undefined") item.conditional = edge.conditional;
				return item;
			})
		};
	}
	addNode(data, id, metadata) {
		if (id !== void 0 && this.nodes[id] !== void 0) throw new Error(`Node with id ${id} already exists`);
		const nodeId = id ?? v4_default();
		const node = {
			id: nodeId,
			data,
			name: nodeDataStr(id, data),
			metadata
		};
		this.nodes[nodeId] = node;
		return node;
	}
	removeNode(node) {
		delete this.nodes[node.id];
		this.edges = this.edges.filter((edge) => edge.source !== node.id && edge.target !== node.id);
	}
	addEdge(source, target, data, conditional) {
		if (this.nodes[source.id] === void 0) throw new Error(`Source node ${source.id} not in graph`);
		if (this.nodes[target.id] === void 0) throw new Error(`Target node ${target.id} not in graph`);
		const edge = {
			source: source.id,
			target: target.id,
			data,
			conditional
		};
		this.edges.push(edge);
		return edge;
	}
	firstNode() {
		return _firstNode(this);
	}
	lastNode() {
		return _lastNode(this);
	}
	/**
	* Add all nodes and edges from another graph.
	* Note this doesn't check for duplicates, nor does it connect the graphs.
	*/
	extend(graph, prefix$1 = "") {
		let finalPrefix = prefix$1;
		const nodeIds = Object.values(graph.nodes).map((node) => node.id);
		if (nodeIds.every(validate_default)) finalPrefix = "";
		const prefixed = (id) => {
			return finalPrefix ? `${finalPrefix}:${id}` : id;
		};
		Object.entries(graph.nodes).forEach(([key, value]) => {
			this.nodes[prefixed(key)] = {
				...value,
				id: prefixed(key)
			};
		});
		const newEdges = graph.edges.map((edge) => {
			return {
				...edge,
				source: prefixed(edge.source),
				target: prefixed(edge.target)
			};
		});
		this.edges = [...this.edges, ...newEdges];
		const first = graph.firstNode();
		const last = graph.lastNode();
		return [first ? {
			id: prefixed(first.id),
			data: first.data
		} : void 0, last ? {
			id: prefixed(last.id),
			data: last.data
		} : void 0];
	}
	trimFirstNode() {
		const firstNode = this.firstNode();
		if (firstNode && _firstNode(this, [firstNode.id])) this.removeNode(firstNode);
	}
	trimLastNode() {
		const lastNode = this.lastNode();
		if (lastNode && _lastNode(this, [lastNode.id])) this.removeNode(lastNode);
	}
	/**
	* Return a new graph with all nodes re-identified,
	* using their unique, readable names where possible.
	*/
	reid() {
		const nodeLabels = Object.fromEntries(Object.values(this.nodes).map((node) => [node.id, node.name]));
		const nodeLabelCounts = /* @__PURE__ */ new Map();
		Object.values(nodeLabels).forEach((label) => {
			nodeLabelCounts.set(label, (nodeLabelCounts.get(label) || 0) + 1);
		});
		const getNodeId = (nodeId) => {
			const label = nodeLabels[nodeId];
			if (validate_default(nodeId) && nodeLabelCounts.get(label) === 1) return label;
			else return nodeId;
		};
		return new Graph({
			nodes: Object.fromEntries(Object.entries(this.nodes).map(([id, node]) => [getNodeId(id), {
				...node,
				id: getNodeId(id)
			}])),
			edges: this.edges.map((edge) => ({
				...edge,
				source: getNodeId(edge.source),
				target: getNodeId(edge.target)
			}))
		});
	}
	drawMermaid(params) {
		const { withStyles, curveStyle, nodeColors = {
			default: "fill:#f2f0ff,line-height:1.2",
			first: "fill-opacity:0",
			last: "fill:#bfb6fc"
		}, wrapLabelNWords } = params ?? {};
		const graph = this.reid();
		const firstNode = graph.firstNode();
		const lastNode = graph.lastNode();
		return drawMermaid(graph.nodes, graph.edges, {
			firstNode: firstNode?.id,
			lastNode: lastNode?.id,
			withStyles,
			curveStyle,
			nodeColors,
			wrapLabelNWords
		});
	}
	async drawMermaidPng(params) {
		const mermaidSyntax = this.drawMermaid(params);
		return drawMermaidPng(mermaidSyntax, { backgroundColor: params?.backgroundColor });
	}
};
/**
* Find the single node that is not a target of any edge.
* Exclude nodes/sources with ids in the exclude list.
* If there is no such node, or there are multiple, return undefined.
* When drawing the graph, this node would be the origin.
*/
function _firstNode(graph, exclude = []) {
	const targets = new Set(graph.edges.filter((edge) => !exclude.includes(edge.source)).map((edge) => edge.target));
	const found = [];
	for (const node of Object.values(graph.nodes)) if (!exclude.includes(node.id) && !targets.has(node.id)) found.push(node);
	return found.length === 1 ? found[0] : void 0;
}
/**
* Find the single node that is not a source of any edge.
* Exclude nodes/targets with ids in the exclude list.
* If there is no such node, or there are multiple, return undefined.
* When drawing the graph, this node would be the destination.
*/
function _lastNode(graph, exclude = []) {
	const sources = new Set(graph.edges.filter((edge) => !exclude.includes(edge.target)).map((edge) => edge.source));
	const found = [];
	for (const node of Object.values(graph.nodes)) if (!exclude.includes(node.id) && !sources.has(node.id)) found.push(node);
	return found.length === 1 ? found[0] : void 0;
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/wrappers.js
function convertToHttpEventStream(stream) {
	const encoder$1 = new TextEncoder();
	const finalStream = new ReadableStream({ async start(controller) {
		for await (const chunk of stream) controller.enqueue(encoder$1.encode(`event: data\ndata: ${JSON.stringify(chunk)}\n\n`));
		controller.enqueue(encoder$1.encode("event: end\n\n"));
		controller.close();
	} });
	return IterableReadableStream.fromReadableStream(finalStream);
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/iter.js
function isIterableIterator(thing) {
	return typeof thing === "object" && thing !== null && typeof thing[Symbol.iterator] === "function" && typeof thing.next === "function";
}
const isIterator = (x) => x != null && typeof x === "object" && "next" in x && typeof x.next === "function";
function isAsyncIterable(thing) {
	return typeof thing === "object" && thing !== null && typeof thing[Symbol.asyncIterator] === "function";
}
function* consumeIteratorInContext(context, iter) {
	while (true) {
		const { value, done } = AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(context), iter.next.bind(iter), true);
		if (done) break;
		else yield value;
	}
}
async function* consumeAsyncIterableInContext(context, iter) {
	const iterator = iter[Symbol.asyncIterator]();
	while (true) {
		const { value, done } = await AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(context), iterator.next.bind(iter), true);
		if (done) break;
		else yield value;
	}
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/runnables/base.js
var import_p_retry = __toESM(require_p_retry(), 1);
function _coerceToDict(value, defaultKey) {
	return value && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object" ? value : { [defaultKey]: value };
}
/**
* A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
* transformed.
*/
var Runnable = class extends Serializable {
	constructor() {
		super(...arguments);
		Object.defineProperty(this, "lc_runnable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
	}
	getName(suffix) {
		const name = this.name ?? this.constructor.lc_name() ?? this.constructor.name;
		return suffix ? `${name}${suffix}` : name;
	}
	/**
	* Bind arguments to a Runnable, returning a new Runnable.
	* @param kwargs
	* @returns A new RunnableBinding that, when invoked, will apply the bound args.
	*
	* @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
	*/
	bind(kwargs) {
		return new RunnableBinding({
			bound: this,
			kwargs,
			config: {}
		});
	}
	/**
	* Return a new Runnable that maps a list of inputs to a list of outputs,
	* by calling invoke() with each input.
	*
	* @deprecated This will be removed in the next breaking release.
	*/
	map() {
		return new RunnableEach({ bound: this });
	}
	/**
	* Add retry logic to an existing runnable.
	* @param fields.stopAfterAttempt The number of attempts to retry.
	* @param fields.onFailedAttempt A function that is called when a retry fails.
	* @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
	*/
	withRetry(fields) {
		return new RunnableRetry({
			bound: this,
			kwargs: {},
			config: {},
			maxAttemptNumber: fields?.stopAfterAttempt,
			...fields
		});
	}
	/**
	* Bind config to a Runnable, returning a new Runnable.
	* @param config New configuration parameters to attach to the new runnable.
	* @returns A new RunnableBinding with a config matching what's passed.
	*/
	withConfig(config) {
		return new RunnableBinding({
			bound: this,
			config,
			kwargs: {}
		});
	}
	/**
	* Create a new runnable from the current one that will try invoking
	* other passed fallback runnables if the initial invocation fails.
	* @param fields.fallbacks Other runnables to call if the runnable errors.
	* @returns A new RunnableWithFallbacks.
	*/
	withFallbacks(fields) {
		const fallbacks = Array.isArray(fields) ? fields : fields.fallbacks;
		return new RunnableWithFallbacks({
			runnable: this,
			fallbacks
		});
	}
	_getOptionsList(options, length = 0) {
		if (Array.isArray(options) && options.length !== length) throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
		if (Array.isArray(options)) return options.map(ensureConfig);
		if (length > 1 && !Array.isArray(options) && options.runId) {
			console.warn("Provided runId will be used only for the first element of the batch.");
			const subsequent = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "runId"));
			return Array.from({ length }, (_, i) => ensureConfig(i === 0 ? options : subsequent));
		}
		return Array.from({ length }, () => ensureConfig(options));
	}
	async batch(inputs, options, batchOptions) {
		const configList = this._getOptionsList(options ?? {}, inputs.length);
		const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
		const caller = new AsyncCaller({
			maxConcurrency,
			onFailedAttempt: (e) => {
				throw e;
			}
		});
		const batchCalls = inputs.map((input, i) => caller.call(async () => {
			try {
				const result = await this.invoke(input, configList[i]);
				return result;
			} catch (e) {
				if (batchOptions?.returnExceptions) return e;
				throw e;
			}
		}));
		return Promise.all(batchCalls);
	}
	/**
	* Default streaming implementation.
	* Subclasses should override this method if they support streaming output.
	* @param input
	* @param options
	*/
	async *_streamIterator(input, options) {
		yield this.invoke(input, options);
	}
	/**
	* Stream output in chunks.
	* @param input
	* @param options
	* @returns A readable stream that is also an iterable.
	*/
	async stream(input, options) {
		const config = ensureConfig(options);
		const wrappedGenerator = new AsyncGeneratorWithSetup({
			generator: this._streamIterator(input, config),
			config
		});
		await wrappedGenerator.setup;
		return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
	}
	_separateRunnableConfigFromCallOptions(options) {
		let runnableConfig;
		if (options === void 0) runnableConfig = ensureConfig(options);
		else runnableConfig = ensureConfig({
			callbacks: options.callbacks,
			tags: options.tags,
			metadata: options.metadata,
			runName: options.runName,
			configurable: options.configurable,
			recursionLimit: options.recursionLimit,
			maxConcurrency: options.maxConcurrency,
			runId: options.runId,
			timeout: options.timeout,
			signal: options.signal
		});
		const callOptions = { ...options };
		delete callOptions.callbacks;
		delete callOptions.tags;
		delete callOptions.metadata;
		delete callOptions.runName;
		delete callOptions.configurable;
		delete callOptions.recursionLimit;
		delete callOptions.maxConcurrency;
		delete callOptions.runId;
		delete callOptions.timeout;
		delete callOptions.signal;
		return [runnableConfig, callOptions];
	}
	async _callWithConfig(func, input, options) {
		const config = ensureConfig(options);
		const callbackManager_ = await getCallbackManagerForConfig(config);
		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, config?.runType, void 0, void 0, config?.runName ?? this.getName());
		delete config.runId;
		let output;
		try {
			const promise = func.call(this, input, config, runManager);
			output = await raceWithSignal(promise, options?.signal);
		} catch (e) {
			await runManager?.handleChainError(e);
			throw e;
		}
		await runManager?.handleChainEnd(_coerceToDict(output, "output"));
		return output;
	}
	/**
	* Internal method that handles batching and configuration for a runnable
	* It takes a function, input values, and optional configuration, and
	* returns a promise that resolves to the output values.
	* @param func The function to be executed for each input value.
	* @param input The input values to be processed.
	* @param config Optional configuration for the function execution.
	* @returns A promise that resolves to the output values.
	*/
	async _batchWithConfig(func, inputs, options, batchOptions) {
		const optionsList = this._getOptionsList(options ?? {}, inputs.length);
		const callbackManagers = await Promise.all(optionsList.map(getCallbackManagerForConfig));
		const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
			const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), optionsList[i].runId, optionsList[i].runType, void 0, void 0, optionsList[i].runName ?? this.getName());
			delete optionsList[i].runId;
			return handleStartRes;
		}));
		let outputs;
		try {
			const promise = func.call(this, inputs, optionsList, runManagers, batchOptions);
			outputs = await raceWithSignal(promise, optionsList?.[0]?.signal);
		} catch (e) {
			await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
			throw e;
		}
		await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(outputs, "output"))));
		return outputs;
	}
	/**
	* Helper method to transform an Iterator of Input values into an Iterator of
	* Output values, with callbacks.
	* Use this to implement `stream()` or `transform()` in Runnable subclasses.
	*/
	async *_transformStreamWithConfig(inputGenerator, transformer, options) {
		let finalInput;
		let finalInputSupported = true;
		let finalOutput;
		let finalOutputSupported = true;
		const config = ensureConfig(options);
		const callbackManager_ = await getCallbackManagerForConfig(config);
		async function* wrapInputForTracing() {
			for await (const chunk of inputGenerator) {
				if (finalInputSupported) if (finalInput === void 0) finalInput = chunk;
				else try {
					finalInput = concat(finalInput, chunk);
				} catch {
					finalInput = void 0;
					finalInputSupported = false;
				}
				yield chunk;
			}
		}
		let runManager;
		try {
			const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, void 0, void 0, config.runName ?? this.getName()), options?.signal, config);
			delete config.runId;
			runManager = pipe.setup;
			const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
			let iterator = pipe.output;
			if (streamEventsHandler !== void 0 && runManager !== void 0) iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
			const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
			if (streamLogHandler !== void 0 && runManager !== void 0) iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
			for await (const chunk of iterator) {
				yield chunk;
				if (finalOutputSupported) if (finalOutput === void 0) finalOutput = chunk;
				else try {
					finalOutput = concat(finalOutput, chunk);
				} catch {
					finalOutput = void 0;
					finalOutputSupported = false;
				}
			}
		} catch (e) {
			await runManager?.handleChainError(e, void 0, void 0, void 0, { inputs: _coerceToDict(finalInput, "input") });
			throw e;
		}
		await runManager?.handleChainEnd(finalOutput ?? {}, void 0, void 0, void 0, { inputs: _coerceToDict(finalInput, "input") });
	}
	getGraph(_) {
		const graph = new Graph();
		const inputNode = graph.addNode({
			name: `${this.getName()}Input`,
			schema: anyType()
		});
		const runnableNode = graph.addNode(this);
		const outputNode = graph.addNode({
			name: `${this.getName()}Output`,
			schema: anyType()
		});
		graph.addEdge(inputNode, runnableNode);
		graph.addEdge(runnableNode, outputNode);
		return graph;
	}
	/**
	* Create a new runnable sequence that runs each individual runnable in series,
	* piping the output of one runnable into another runnable or runnable-like.
	* @param coerceable A runnable, function, or object whose values are functions or runnables.
	* @returns A new runnable sequence.
	*/
	pipe(coerceable) {
		return new RunnableSequence({
			first: this,
			last: _coerceToRunnable(coerceable)
		});
	}
	/**
	* Pick keys from the dict output of this runnable. Returns a new runnable.
	*/
	pick(keys) {
		return this.pipe(new RunnablePick(keys));
	}
	/**
	* Assigns new fields to the dict output of this runnable. Returns a new runnable.
	*/
	assign(mapping) {
		return this.pipe(new RunnableAssign(new RunnableMap({ steps: mapping })));
	}
	/**
	* Default implementation of transform, which buffers input and then calls stream.
	* Subclasses should override this method if they can start producing output while
	* input is still being generated.
	* @param generator
	* @param options
	*/
	async *transform(generator, options) {
		let finalChunk;
		for await (const chunk of generator) if (finalChunk === void 0) finalChunk = chunk;
		else finalChunk = concat(finalChunk, chunk);
		yield* this._streamIterator(finalChunk, ensureConfig(options));
	}
	/**
	* Stream all output from a runnable, as reported to the callback system.
	* This includes all inner runs of LLMs, Retrievers, Tools, etc.
	* Output is streamed as Log objects, which include a list of
	* jsonpatch ops that describe how the state of the run has changed in each
	* step, and the final state of the run.
	* The jsonpatch ops can be applied in order to construct state.
	* @param input
	* @param options
	* @param streamOptions
	*/
	async *streamLog(input, options, streamOptions) {
		const logStreamCallbackHandler = new LogStreamCallbackHandler({
			...streamOptions,
			autoClose: false,
			_schemaFormat: "original"
		});
		const config = ensureConfig(options);
		yield* this._streamLog(input, logStreamCallbackHandler, config);
	}
	async *_streamLog(input, logStreamCallbackHandler, config) {
		const { callbacks } = config;
		if (callbacks === void 0) config.callbacks = [logStreamCallbackHandler];
		else if (Array.isArray(callbacks)) config.callbacks = callbacks.concat([logStreamCallbackHandler]);
		else {
			const copiedCallbacks = callbacks.copy();
			copiedCallbacks.addHandler(logStreamCallbackHandler, true);
			config.callbacks = copiedCallbacks;
		}
		const runnableStreamPromise = this.stream(input, config);
		async function consumeRunnableStream() {
			try {
				const runnableStream = await runnableStreamPromise;
				for await (const chunk of runnableStream) {
					const patch$2 = new RunLogPatch({ ops: [{
						op: "add",
						path: "/streamed_output/-",
						value: chunk
					}] });
					await logStreamCallbackHandler.writer.write(patch$2);
				}
			} finally {
				await logStreamCallbackHandler.writer.close();
			}
		}
		const runnableStreamConsumePromise = consumeRunnableStream();
		try {
			for await (const log of logStreamCallbackHandler) yield log;
		} finally {
			await runnableStreamConsumePromise;
		}
	}
	streamEvents(input, options, streamOptions) {
		let stream;
		if (options.version === "v1") stream = this._streamEventsV1(input, options, streamOptions);
		else if (options.version === "v2") stream = this._streamEventsV2(input, options, streamOptions);
		else throw new Error(`Only versions "v1" and "v2" of the schema are currently supported.`);
		if (options.encoding === "text/event-stream") return convertToHttpEventStream(stream);
		else return IterableReadableStream.fromAsyncGenerator(stream);
	}
	async *_streamEventsV2(input, options, streamOptions) {
		const eventStreamer = new EventStreamCallbackHandler({
			...streamOptions,
			autoClose: false
		});
		const config = ensureConfig(options);
		const runId = config.runId ?? v4_default();
		config.runId = runId;
		const callbacks = config.callbacks;
		if (callbacks === void 0) config.callbacks = [eventStreamer];
		else if (Array.isArray(callbacks)) config.callbacks = callbacks.concat(eventStreamer);
		else {
			const copiedCallbacks = callbacks.copy();
			copiedCallbacks.addHandler(eventStreamer, true);
			config.callbacks = copiedCallbacks;
		}
		const abortController = new AbortController();
		const outerThis = this;
		async function consumeRunnableStream() {
			try {
				let signal;
				if (options?.signal) if ("any" in AbortSignal) signal = AbortSignal.any([abortController.signal, options.signal]);
				else {
					signal = options.signal;
					options.signal.addEventListener("abort", () => {
						abortController.abort();
					}, { once: true });
				}
				else signal = abortController.signal;
				const runnableStream = await outerThis.stream(input, {
					...config,
					signal
				});
				const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
				for await (const _ of tappedStream) if (abortController.signal.aborted) break;
			} finally {
				await eventStreamer.finish();
			}
		}
		const runnableStreamConsumePromise = consumeRunnableStream();
		let firstEventSent = false;
		let firstEventRunId;
		try {
			for await (const event of eventStreamer) {
				if (!firstEventSent) {
					event.data.input = input;
					firstEventSent = true;
					firstEventRunId = event.run_id;
					yield event;
					continue;
				}
				if (event.run_id === firstEventRunId && event.event.endsWith("_end")) {
					if (event.data?.input) delete event.data.input;
				}
				yield event;
			}
		} finally {
			abortController.abort();
			await runnableStreamConsumePromise;
		}
	}
	async *_streamEventsV1(input, options, streamOptions) {
		let runLog;
		let hasEncounteredStartEvent = false;
		const config = ensureConfig(options);
		const rootTags = config.tags ?? [];
		const rootMetadata = config.metadata ?? {};
		const rootName = config.runName ?? this.getName();
		const logStreamCallbackHandler = new LogStreamCallbackHandler({
			...streamOptions,
			autoClose: false,
			_schemaFormat: "streaming_events"
		});
		const rootEventFilter = new _RootEventFilter({ ...streamOptions });
		const logStream = this._streamLog(input, logStreamCallbackHandler, config);
		for await (const log of logStream) {
			if (!runLog) runLog = RunLog.fromRunLogPatch(log);
			else runLog = runLog.concat(log);
			if (runLog.state === void 0) throw new Error(`Internal error: "streamEvents" state is missing. Please open a bug report.`);
			if (!hasEncounteredStartEvent) {
				hasEncounteredStartEvent = true;
				const state$2 = { ...runLog.state };
				const event = {
					run_id: state$2.id,
					event: `on_${state$2.type}_start`,
					name: rootName,
					tags: rootTags,
					metadata: rootMetadata,
					data: { input }
				};
				if (rootEventFilter.includeEvent(event, state$2.type)) yield event;
			}
			const paths = log.ops.filter((op) => op.path.startsWith("/logs/")).map((op) => op.path.split("/")[2]);
			const dedupedPaths = [...new Set(paths)];
			for (const path of dedupedPaths) {
				let eventType;
				let data = {};
				const logEntry = runLog.state.logs[path];
				if (logEntry.end_time === void 0) if (logEntry.streamed_output.length > 0) eventType = "stream";
				else eventType = "start";
				else eventType = "end";
				if (eventType === "start") {
					if (logEntry.inputs !== void 0) data.input = logEntry.inputs;
				} else if (eventType === "end") {
					if (logEntry.inputs !== void 0) data.input = logEntry.inputs;
					data.output = logEntry.final_output;
				} else if (eventType === "stream") {
					const chunkCount = logEntry.streamed_output.length;
					if (chunkCount !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${logEntry.name}"`);
					data = { chunk: logEntry.streamed_output[0] };
					logEntry.streamed_output = [];
				}
				yield {
					event: `on_${logEntry.type}_${eventType}`,
					name: logEntry.name,
					run_id: logEntry.id,
					tags: logEntry.tags,
					metadata: logEntry.metadata,
					data
				};
			}
			const { state: state$1 } = runLog;
			if (state$1.streamed_output.length > 0) {
				const chunkCount = state$1.streamed_output.length;
				if (chunkCount !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state$1.name}"`);
				const data = { chunk: state$1.streamed_output[0] };
				state$1.streamed_output = [];
				const event = {
					event: `on_${state$1.type}_stream`,
					run_id: state$1.id,
					tags: rootTags,
					metadata: rootMetadata,
					name: rootName,
					data
				};
				if (rootEventFilter.includeEvent(event, state$1.type)) yield event;
			}
		}
		const state = runLog?.state;
		if (state !== void 0) {
			const event = {
				event: `on_${state.type}_end`,
				name: rootName,
				run_id: state.id,
				tags: rootTags,
				metadata: rootMetadata,
				data: { output: state.final_output }
			};
			if (rootEventFilter.includeEvent(event, state.type)) yield event;
		}
	}
	static isRunnable(thing) {
		return isRunnableInterface(thing);
	}
	/**
	* Bind lifecycle listeners to a Runnable, returning a new Runnable.
	* The Run object contains information about the run, including its id,
	* type, input, output, error, startTime, endTime, and any tags or metadata
	* added to the run.
	*
	* @param {Object} params - The object containing the callback functions.
	* @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object.
	* @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object.
	* @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object.
	*/
	withListeners({ onStart, onEnd, onError }) {
		return new RunnableBinding({
			bound: this,
			config: {},
			configFactories: [(config) => ({ callbacks: [new RootListenersTracer({
				config,
				onStart,
				onEnd,
				onError
			})] })]
		});
	}
	/**
	* Convert a runnable to a tool. Return a new instance of `RunnableToolLike`
	* which contains the runnable, name, description and schema.
	*
	* @template {T extends RunInput = RunInput} RunInput - The input type of the runnable. Should be the same as the `RunInput` type of the runnable.
	*
	* @param fields
	* @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
	* @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
	* @param {z.ZodType<T>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
	* @returns {RunnableToolLike<z.ZodType<T>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
	*/
	asTool(fields) {
		return convertRunnableToTool(this, fields);
	}
};
/**
* Wraps a runnable and applies partial config upon invocation.
*
* @example
* ```typescript
* import {
*   type RunnableConfig,
*   RunnableLambda,
* } from "@langchain/core/runnables";
*
* const enhanceProfile = (
*   profile: Record<string, any>,
*   config?: RunnableConfig
* ) => {
*   if (config?.configurable?.role) {
*     return { ...profile, role: config.configurable.role };
*   }
*   return profile;
* };
*
* const runnable = RunnableLambda.from(enhanceProfile);
*
* // Bind configuration to the runnable to set the user's role dynamically
* const adminRunnable = runnable.bind({ configurable: { role: "Admin" } });
* const userRunnable = runnable.bind({ configurable: { role: "User" } });
*
* const result1 = await adminRunnable.invoke({
*   name: "Alice",
*   email: "alice@example.com"
* });
*
* // { name: "Alice", email: "alice@example.com", role: "Admin" }
*
* const result2 = await userRunnable.invoke({
*   name: "Bob",
*   email: "bob@example.com"
* });
*
* // { name: "Bob", email: "bob@example.com", role: "User" }
* ```
*/
var RunnableBinding = class RunnableBinding extends Runnable {
	static lc_name() {
		return "RunnableBinding";
	}
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "bound", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "config", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "kwargs", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "configFactories", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.bound = fields.bound;
		this.kwargs = fields.kwargs;
		this.config = fields.config;
		this.configFactories = fields.configFactories;
	}
	getName(suffix) {
		return this.bound.getName(suffix);
	}
	async _mergeConfig(...options) {
		const config = mergeConfigs(this.config, ...options);
		return mergeConfigs(config, ...this.configFactories ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config))) : []);
	}
	/**
	* Binds the runnable with the specified arguments.
	* @param kwargs The arguments to bind the runnable with.
	* @returns A new instance of the `RunnableBinding` class that is bound with the specified arguments.
	*
	* @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
	*/
	bind(kwargs) {
		return new this.constructor({
			bound: this.bound,
			kwargs: {
				...this.kwargs,
				...kwargs
			},
			config: this.config
		});
	}
	withConfig(config) {
		return new this.constructor({
			bound: this.bound,
			kwargs: this.kwargs,
			config: {
				...this.config,
				...config
			}
		});
	}
	withRetry(fields) {
		return new RunnableRetry({
			bound: this.bound,
			kwargs: this.kwargs,
			config: this.config,
			maxAttemptNumber: fields?.stopAfterAttempt,
			...fields
		});
	}
	async invoke(input, options) {
		return this.bound.invoke(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
	}
	async batch(inputs, options, batchOptions) {
		const mergedOptions = Array.isArray(options) ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(ensureConfig(individualOption), this.kwargs))) : await this._mergeConfig(ensureConfig(options), this.kwargs);
		return this.bound.batch(inputs, mergedOptions, batchOptions);
	}
	async *_streamIterator(input, options) {
		yield* this.bound._streamIterator(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
	}
	async stream(input, options) {
		return this.bound.stream(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
	}
	async *transform(generator, options) {
		yield* this.bound.transform(generator, await this._mergeConfig(ensureConfig(options), this.kwargs));
	}
	streamEvents(input, options, streamOptions) {
		const outerThis = this;
		const generator = async function* () {
			yield* outerThis.bound.streamEvents(input, {
				...await outerThis._mergeConfig(ensureConfig(options), outerThis.kwargs),
				version: options.version
			}, streamOptions);
		};
		return IterableReadableStream.fromAsyncGenerator(generator());
	}
	static isRunnableBinding(thing) {
		return thing.bound && Runnable.isRunnable(thing.bound);
	}
	/**
	* Bind lifecycle listeners to a Runnable, returning a new Runnable.
	* The Run object contains information about the run, including its id,
	* type, input, output, error, startTime, endTime, and any tags or metadata
	* added to the run.
	*
	* @param {Object} params - The object containing the callback functions.
	* @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object.
	* @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object.
	* @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object.
	*/
	withListeners({ onStart, onEnd, onError }) {
		return new RunnableBinding({
			bound: this.bound,
			kwargs: this.kwargs,
			config: this.config,
			configFactories: [(config) => ({ callbacks: [new RootListenersTracer({
				config,
				onStart,
				onEnd,
				onError
			})] })]
		});
	}
};
/**
* A runnable that delegates calls to another runnable
* with each element of the input sequence.
* @example
* ```typescript
* import { RunnableEach, RunnableLambda } from "@langchain/core/runnables";
*
* const toUpperCase = (input: string): string => input.toUpperCase();
* const addGreeting = (input: string): string => `Hello, ${input}!`;
*
* const upperCaseLambda = RunnableLambda.from(toUpperCase);
* const greetingLambda = RunnableLambda.from(addGreeting);
*
* const chain = new RunnableEach({
*   bound: upperCaseLambda.pipe(greetingLambda),
* });
*
* const result = await chain.invoke(["alice", "bob", "carol"])
*
* // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
* ```
*
* @deprecated This will be removed in the next breaking release.
*/
var RunnableEach = class RunnableEach extends Runnable {
	static lc_name() {
		return "RunnableEach";
	}
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "bound", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.bound = fields.bound;
	}
	/**
	* Binds the runnable with the specified arguments.
	* @param kwargs The arguments to bind the runnable with.
	* @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
	*
	* @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
	*/
	bind(kwargs) {
		return new RunnableEach({ bound: this.bound.bind(kwargs) });
	}
	/**
	* Invokes the runnable with the specified input and configuration.
	* @param input The input to invoke the runnable with.
	* @param config The configuration to invoke the runnable with.
	* @returns A promise that resolves to the output of the runnable.
	*/
	async invoke(inputs, config) {
		return this._callWithConfig(this._invoke.bind(this), inputs, config);
	}
	/**
	* A helper method that is used to invoke the runnable with the specified input and configuration.
	* @param input The input to invoke the runnable with.
	* @param config The configuration to invoke the runnable with.
	* @returns A promise that resolves to the output of the runnable.
	*/
	async _invoke(inputs, config, runManager) {
		return this.bound.batch(inputs, patchConfig(config, { callbacks: runManager?.getChild() }));
	}
	/**
	* Bind lifecycle listeners to a Runnable, returning a new Runnable.
	* The Run object contains information about the run, including its id,
	* type, input, output, error, startTime, endTime, and any tags or metadata
	* added to the run.
	*
	* @param {Object} params - The object containing the callback functions.
	* @param {(run: Run) => void} params.onStart - Called before the runnable starts running, with the Run object.
	* @param {(run: Run) => void} params.onEnd - Called after the runnable finishes running, with the Run object.
	* @param {(run: Run) => void} params.onError - Called if the runnable throws an error, with the Run object.
	*/
	withListeners({ onStart, onEnd, onError }) {
		return new RunnableEach({ bound: this.bound.withListeners({
			onStart,
			onEnd,
			onError
		}) });
	}
};
/**
* Base class for runnables that can be retried a
* specified number of times.
* @example
* ```typescript
* import {
*   RunnableLambda,
*   RunnableRetry,
* } from "@langchain/core/runnables";
*
* // Simulate an API call that fails
* const simulateApiCall = (input: string): string => {
*   console.log(`Attempting API call with input: ${input}`);
*   throw new Error("API call failed due to network issue");
* };
*
* const apiCallLambda = RunnableLambda.from(simulateApiCall);
*
* // Apply retry logic using the .withRetry() method
* const apiCallWithRetry = apiCallLambda.withRetry({ stopAfterAttempt: 3 });
*
* // Alternatively, create a RunnableRetry instance manually
* const manualRetry = new RunnableRetry({
*   bound: apiCallLambda,
*   maxAttemptNumber: 3,
*   config: {},
* });
*
* // Example invocation using the .withRetry() method
* const res = await apiCallWithRetry
*   .invoke("Request 1")
*   .catch((error) => {
*     console.error("Failed after multiple retries:", error.message);
*   });
*
* // Example invocation using the manual retry instance
* const res2 = await manualRetry
*   .invoke("Request 2")
*   .catch((error) => {
*     console.error("Failed after multiple retries:", error.message);
*   });
* ```
*/
var RunnableRetry = class extends RunnableBinding {
	static lc_name() {
		return "RunnableRetry";
	}
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "maxAttemptNumber", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: 3
		});
		Object.defineProperty(this, "onFailedAttempt", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: () => {}
		});
		this.maxAttemptNumber = fields.maxAttemptNumber ?? this.maxAttemptNumber;
		this.onFailedAttempt = fields.onFailedAttempt ?? this.onFailedAttempt;
	}
	_patchConfigForRetry(attempt, config, runManager) {
		const tag = attempt > 1 ? `retry:attempt:${attempt}` : void 0;
		return patchConfig(config, { callbacks: runManager?.getChild(tag) });
	}
	async _invoke(input, config, runManager) {
		return (0, import_p_retry.default)((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
			onFailedAttempt: (error) => this.onFailedAttempt(error, input),
			retries: Math.max(this.maxAttemptNumber - 1, 0),
			randomize: true
		});
	}
	/**
	* Method that invokes the runnable with the specified input, run manager,
	* and config. It handles the retry logic by catching any errors and
	* recursively invoking itself with the updated config for the next retry
	* attempt.
	* @param input The input for the runnable.
	* @param runManager The run manager for the runnable.
	* @param config The config for the runnable.
	* @returns A promise that resolves to the output of the runnable.
	*/
	async invoke(input, config) {
		return this._callWithConfig(this._invoke.bind(this), input, config);
	}
	async _batch(inputs, configs, runManagers, batchOptions) {
		const resultsMap = {};
		try {
			await (0, import_p_retry.default)(async (attemptNumber) => {
				const remainingIndexes = inputs.map((_, i) => i).filter((i) => resultsMap[i.toString()] === void 0 || resultsMap[i.toString()] instanceof Error);
				const remainingInputs = remainingIndexes.map((i) => inputs[i]);
				const patchedConfigs = remainingIndexes.map((i) => this._patchConfigForRetry(attemptNumber, configs?.[i], runManagers?.[i]));
				const results = await super.batch(remainingInputs, patchedConfigs, {
					...batchOptions,
					returnExceptions: true
				});
				let firstException;
				for (let i = 0; i < results.length; i += 1) {
					const result = results[i];
					const resultMapIndex = remainingIndexes[i];
					if (result instanceof Error) {
						if (firstException === void 0) {
							firstException = result;
							firstException.input = remainingInputs[i];
						}
					}
					resultsMap[resultMapIndex.toString()] = result;
				}
				if (firstException) throw firstException;
				return results;
			}, {
				onFailedAttempt: (error) => this.onFailedAttempt(error, error.input),
				retries: Math.max(this.maxAttemptNumber - 1, 0),
				randomize: true
			});
		} catch (e) {
			if (batchOptions?.returnExceptions !== true) throw e;
		}
		return Object.keys(resultsMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10)).map((key) => resultsMap[parseInt(key, 10)]);
	}
	async batch(inputs, options, batchOptions) {
		return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions);
	}
};
/**
* A sequence of runnables, where the output of each is the input of the next.
* @example
* ```typescript
* const promptTemplate = PromptTemplate.fromTemplate(
*   "Tell me a joke about {topic}",
* );
* const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]);
* const result = await chain.invoke({ topic: "bears" });
* ```
*/
var RunnableSequence = class RunnableSequence extends Runnable {
	static lc_name() {
		return "RunnableSequence";
	}
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "first", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "middle", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: []
		});
		Object.defineProperty(this, "last", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "omitSequenceTags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		this.first = fields.first;
		this.middle = fields.middle ?? this.middle;
		this.last = fields.last;
		this.name = fields.name;
		this.omitSequenceTags = fields.omitSequenceTags ?? this.omitSequenceTags;
	}
	get steps() {
		return [
			this.first,
			...this.middle,
			this.last
		];
	}
	async invoke(input, options) {
		const config = ensureConfig(options);
		const callbackManager_ = await getCallbackManagerForConfig(config);
		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, void 0, void 0, void 0, config?.runName);
		delete config.runId;
		let nextStepInput = input;
		let finalOutput;
		try {
			const initialSteps = [this.first, ...this.middle];
			for (let i = 0; i < initialSteps.length; i += 1) {
				const step = initialSteps[i];
				const promise = step.invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
				nextStepInput = await raceWithSignal(promise, options?.signal);
			}
			if (options?.signal?.aborted) throw new Error("Aborted");
			finalOutput = await this.last.invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${this.steps.length}`) }));
		} catch (e) {
			await runManager?.handleChainError(e);
			throw e;
		}
		await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
		return finalOutput;
	}
	async batch(inputs, options, batchOptions) {
		const configList = this._getOptionsList(options ?? {}, inputs.length);
		const callbackManagers = await Promise.all(configList.map(getCallbackManagerForConfig));
		const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
			const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, void 0, void 0, void 0, configList[i].runName);
			delete configList[i].runId;
			return handleStartRes;
		}));
		let nextStepInputs = inputs;
		try {
			for (let i = 0; i < this.steps.length; i += 1) {
				const step = this.steps[i];
				const promise = step.batch(nextStepInputs, runManagers.map((runManager, j) => {
					const childRunManager = runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`);
					return patchConfig(configList[j], { callbacks: childRunManager });
				}), batchOptions);
				nextStepInputs = await raceWithSignal(promise, configList[0]?.signal);
			}
		} catch (e) {
			await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
			throw e;
		}
		await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(nextStepInputs, "output"))));
		return nextStepInputs;
	}
	async *_streamIterator(input, options) {
		const callbackManager_ = await getCallbackManagerForConfig(options);
		const { runId,...otherOptions } = options ?? {};
		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherOptions?.runName);
		const steps = [
			this.first,
			...this.middle,
			this.last
		];
		let concatSupported = true;
		let finalOutput;
		async function* inputGenerator() {
			yield input;
		}
		try {
			let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:1`) }));
			for (let i = 1; i < steps.length; i += 1) {
				const step = steps[i];
				finalGenerator = await step.transform(finalGenerator, patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
			}
			for await (const chunk of finalGenerator) {
				options?.signal?.throwIfAborted();
				yield chunk;
				if (concatSupported) if (finalOutput === void 0) finalOutput = chunk;
				else try {
					finalOutput = concat(finalOutput, chunk);
				} catch (e) {
					finalOutput = void 0;
					concatSupported = false;
				}
			}
		} catch (e) {
			await runManager?.handleChainError(e);
			throw e;
		}
		await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
	}
	getGraph(config) {
		const graph = new Graph();
		let currentLastNode = null;
		this.steps.forEach((step, index) => {
			const stepGraph = step.getGraph(config);
			if (index !== 0) stepGraph.trimFirstNode();
			if (index !== this.steps.length - 1) stepGraph.trimLastNode();
			graph.extend(stepGraph);
			const stepFirstNode = stepGraph.firstNode();
			if (!stepFirstNode) throw new Error(`Runnable ${step} has no first node`);
			if (currentLastNode) graph.addEdge(currentLastNode, stepFirstNode);
			currentLastNode = stepGraph.lastNode();
		});
		return graph;
	}
	pipe(coerceable) {
		if (RunnableSequence.isRunnableSequence(coerceable)) return new RunnableSequence({
			first: this.first,
			middle: this.middle.concat([
				this.last,
				coerceable.first,
				...coerceable.middle
			]),
			last: coerceable.last,
			name: this.name ?? coerceable.name
		});
		else return new RunnableSequence({
			first: this.first,
			middle: [...this.middle, this.last],
			last: _coerceToRunnable(coerceable),
			name: this.name
		});
	}
	static isRunnableSequence(thing) {
		return Array.isArray(thing.middle) && Runnable.isRunnable(thing);
	}
	static from([first, ...runnables], nameOrFields) {
		let extra = {};
		if (typeof nameOrFields === "string") extra.name = nameOrFields;
		else if (nameOrFields !== void 0) extra = nameOrFields;
		return new RunnableSequence({
			...extra,
			first: _coerceToRunnable(first),
			middle: runnables.slice(0, -1).map(_coerceToRunnable),
			last: _coerceToRunnable(runnables[runnables.length - 1])
		});
	}
};
/**
* A runnable that runs a mapping of runnables in parallel,
* and returns a mapping of their outputs.
* @example
* ```typescript
* const mapChain = RunnableMap.from({
*   joke: PromptTemplate.fromTemplate("Tell me a joke about {topic}").pipe(
*     new ChatAnthropic({}),
*   ),
*   poem: PromptTemplate.fromTemplate("write a 2-line poem about {topic}").pipe(
*     new ChatAnthropic({}),
*   ),
* });
* const result = await mapChain.invoke({ topic: "bear" });
* ```
*/
var RunnableMap = class RunnableMap extends Runnable {
	static lc_name() {
		return "RunnableMap";
	}
	getStepsKeys() {
		return Object.keys(this.steps);
	}
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "steps", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.steps = {};
		for (const [key, value] of Object.entries(fields.steps)) this.steps[key] = _coerceToRunnable(value);
	}
	static from(steps) {
		return new RunnableMap({ steps });
	}
	async invoke(input, options) {
		const config = ensureConfig(options);
		const callbackManager_ = await getCallbackManagerForConfig(config);
		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), { input }, config.runId, void 0, void 0, void 0, config?.runName);
		delete config.runId;
		const output = {};
		try {
			const promises = Object.entries(this.steps).map(async ([key, runnable]) => {
				output[key] = await runnable.invoke(input, patchConfig(config, { callbacks: runManager?.getChild(`map:key:${key}`) }));
			});
			await raceWithSignal(Promise.all(promises), options?.signal);
		} catch (e) {
			await runManager?.handleChainError(e);
			throw e;
		}
		await runManager?.handleChainEnd(output);
		return output;
	}
	async *_transform(generator, runManager, options) {
		const steps = { ...this.steps };
		const inputCopies = atee(generator, Object.keys(steps).length);
		const tasks = new Map(Object.entries(steps).map(([key, runnable], i) => {
			const gen = runnable.transform(inputCopies[i], patchConfig(options, { callbacks: runManager?.getChild(`map:key:${key}`) }));
			return [key, gen.next().then((result) => ({
				key,
				gen,
				result
			}))];
		}));
		while (tasks.size) {
			const promise = Promise.race(tasks.values());
			const { key, result, gen } = await raceWithSignal(promise, options?.signal);
			tasks.delete(key);
			if (!result.done) {
				yield { [key]: result.value };
				tasks.set(key, gen.next().then((result$1) => ({
					key,
					gen,
					result: result$1
				})));
			}
		}
	}
	transform(generator, options) {
		return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
	}
	async stream(input, options) {
		async function* generator() {
			yield input;
		}
		const config = ensureConfig(options);
		const wrappedGenerator = new AsyncGeneratorWithSetup({
			generator: this.transform(generator(), config),
			config
		});
		await wrappedGenerator.setup;
		return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
	}
};
/**
* A runnable that wraps a traced LangSmith function.
*/
var RunnableTraceable = class RunnableTraceable extends Runnable {
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: false
		});
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "func", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		if (!isTraceableFunction(fields.func)) throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
		this.func = fields.func;
	}
	async invoke(input, options) {
		const [config] = this._getOptionsList(options ?? {}, 1);
		const callbacks = await getCallbackManagerForConfig(config);
		const promise = this.func(patchConfig(config, { callbacks }), input);
		return raceWithSignal(promise, config?.signal);
	}
	async *_streamIterator(input, options) {
		const [config] = this._getOptionsList(options ?? {}, 1);
		const result = await this.invoke(input, options);
		if (isAsyncIterable(result)) {
			for await (const item of result) {
				config?.signal?.throwIfAborted();
				yield item;
			}
			return;
		}
		if (isIterator(result)) {
			while (true) {
				config?.signal?.throwIfAborted();
				const state = result.next();
				if (state.done) break;
				yield state.value;
			}
			return;
		}
		yield result;
	}
	static from(func) {
		return new RunnableTraceable({ func });
	}
};
function assertNonTraceableFunction(func) {
	if (isTraceableFunction(func)) throw new Error("RunnableLambda requires a function that is not wrapped in traceable higher-order function. This shouldn't happen.");
}
/**
* A runnable that wraps an arbitrary function that takes a single argument.
* @example
* ```typescript
* import { RunnableLambda } from "@langchain/core/runnables";
*
* const add = (input: { x: number; y: number }) => input.x + input.y;
*
* const multiply = (input: { value: number; multiplier: number }) =>
*   input.value * input.multiplier;
*
* // Create runnables for the functions
* const addLambda = RunnableLambda.from(add);
* const multiplyLambda = RunnableLambda.from(multiply);
*
* // Chain the lambdas for a mathematical operation
* const chainedLambda = addLambda.pipe((result) =>
*   multiplyLambda.invoke({ value: result, multiplier: 2 })
* );
*
* // Example invocation of the chainedLambda
* const result = await chainedLambda.invoke({ x: 2, y: 3 });
*
* // Will log "10" (since (2 + 3) * 2 = 10)
* ```
*/
var RunnableLambda = class RunnableLambda extends Runnable {
	static lc_name() {
		return "RunnableLambda";
	}
	constructor(fields) {
		if (isTraceableFunction(fields.func)) return RunnableTraceable.from(fields.func);
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "func", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		assertNonTraceableFunction(fields.func);
		this.func = fields.func;
	}
	static from(func) {
		return new RunnableLambda({ func });
	}
	async _invoke(input, config, runManager) {
		return new Promise((resolve, reject) => {
			const childConfig = patchConfig(config, {
				callbacks: runManager?.getChild(),
				recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1
			});
			AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
				try {
					let output = await this.func(input, { ...childConfig });
					if (output && Runnable.isRunnable(output)) {
						if (config?.recursionLimit === 0) throw new Error("Recursion limit reached.");
						output = await output.invoke(input, {
							...childConfig,
							recursionLimit: (childConfig.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1
						});
					} else if (isAsyncIterable(output)) {
						let finalOutput;
						for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
							config?.signal?.throwIfAborted();
							if (finalOutput === void 0) finalOutput = chunk;
							else try {
								finalOutput = concat(finalOutput, chunk);
							} catch (e) {
								finalOutput = chunk;
							}
						}
						output = finalOutput;
					} else if (isIterableIterator(output)) {
						let finalOutput;
						for (const chunk of consumeIteratorInContext(childConfig, output)) {
							config?.signal?.throwIfAborted();
							if (finalOutput === void 0) finalOutput = chunk;
							else try {
								finalOutput = concat(finalOutput, chunk);
							} catch (e) {
								finalOutput = chunk;
							}
						}
						output = finalOutput;
					}
					resolve(output);
				} catch (e) {
					reject(e);
				}
			});
		});
	}
	async invoke(input, options) {
		return this._callWithConfig(this._invoke.bind(this), input, options);
	}
	async *_transform(generator, runManager, config) {
		let finalChunk;
		for await (const chunk of generator) if (finalChunk === void 0) finalChunk = chunk;
		else try {
			finalChunk = concat(finalChunk, chunk);
		} catch (e) {
			finalChunk = chunk;
		}
		const childConfig = patchConfig(config, {
			callbacks: runManager?.getChild(),
			recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1
		});
		const output = await new Promise((resolve, reject) => {
			AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
				try {
					const res = await this.func(finalChunk, {
						...childConfig,
						config: childConfig
					});
					resolve(res);
				} catch (e) {
					reject(e);
				}
			});
		});
		if (output && Runnable.isRunnable(output)) {
			if (config?.recursionLimit === 0) throw new Error("Recursion limit reached.");
			const stream = await output.stream(finalChunk, childConfig);
			for await (const chunk of stream) yield chunk;
		} else if (isAsyncIterable(output)) for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
			config?.signal?.throwIfAborted();
			yield chunk;
		}
		else if (isIterableIterator(output)) for (const chunk of consumeIteratorInContext(childConfig, output)) {
			config?.signal?.throwIfAborted();
			yield chunk;
		}
		else yield output;
	}
	transform(generator, options) {
		return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
	}
	async stream(input, options) {
		async function* generator() {
			yield input;
		}
		const config = ensureConfig(options);
		const wrappedGenerator = new AsyncGeneratorWithSetup({
			generator: this.transform(generator(), config),
			config
		});
		await wrappedGenerator.setup;
		return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
	}
};
/**
* A runnable that runs a mapping of runnables in parallel,
* and returns a mapping of their outputs.
* @example
* ```typescript
* import {
*   RunnableLambda,
*   RunnableParallel,
* } from "@langchain/core/runnables";
*
* const addYears = (age: number): number => age + 5;
* const yearsToFifty = (age: number): number => 50 - age;
* const yearsToHundred = (age: number): number => 100 - age;
*
* const addYearsLambda = RunnableLambda.from(addYears);
* const milestoneFiftyLambda = RunnableLambda.from(yearsToFifty);
* const milestoneHundredLambda = RunnableLambda.from(yearsToHundred);
*
* // Pipe will coerce objects into RunnableParallel by default, but we
* // explicitly instantiate one here to demonstrate
* const sequence = addYearsLambda.pipe(
*   RunnableParallel.from({
*     years_to_fifty: milestoneFiftyLambda,
*     years_to_hundred: milestoneHundredLambda,
*   })
* );
*
* // Invoke the sequence with a single age input
* const res = sequence.invoke(25);
*
* // { years_to_fifty: 25, years_to_hundred: 75 }
* ```
*/
var RunnableParallel = class extends RunnableMap {};
/**
* A Runnable that can fallback to other Runnables if it fails.
* External APIs (e.g., APIs for a language model) may at times experience
* degraded performance or even downtime.
*
* In these cases, it can be useful to have a fallback Runnable that can be
* used in place of the original Runnable (e.g., fallback to another LLM provider).
*
* Fallbacks can be defined at the level of a single Runnable, or at the level
* of a chain of Runnables. Fallbacks are tried in order until one succeeds or
* all fail.
*
* While you can instantiate a `RunnableWithFallbacks` directly, it is usually
* more convenient to use the `withFallbacks` method on an existing Runnable.
*
* When streaming, fallbacks will only be called on failures during the initial
* stream creation. Errors that occur after a stream starts will not fallback
* to the next Runnable.
*
* @example
* ```typescript
* import {
*   RunnableLambda,
*   RunnableWithFallbacks,
* } from "@langchain/core/runnables";
*
* const primaryOperation = (input: string): string => {
*   if (input !== "safe") {
*     throw new Error("Primary operation failed due to unsafe input");
*   }
*   return `Processed: ${input}`;
* };
*
* // Define a fallback operation that processes the input differently
* const fallbackOperation = (input: string): string =>
*   `Fallback processed: ${input}`;
*
* const primaryRunnable = RunnableLambda.from(primaryOperation);
* const fallbackRunnable = RunnableLambda.from(fallbackOperation);
*
* // Apply the fallback logic using the .withFallbacks() method
* const runnableWithFallback = primaryRunnable.withFallbacks([fallbackRunnable]);
*
* // Alternatively, create a RunnableWithFallbacks instance manually
* const manualFallbackChain = new RunnableWithFallbacks({
*   runnable: primaryRunnable,
*   fallbacks: [fallbackRunnable],
* });
*
* // Example invocation using .withFallbacks()
* const res = await runnableWithFallback
*   .invoke("unsafe input")
*   .catch((error) => {
*     console.error("Failed after all attempts:", error.message);
*   });
*
* // "Fallback processed: unsafe input"
*
* // Example invocation using manual instantiation
* const res = await manualFallbackChain
*   .invoke("safe")
*   .catch((error) => {
*     console.error("Failed after all attempts:", error.message);
*   });
*
* // "Processed: safe"
* ```
*/
var RunnableWithFallbacks = class extends Runnable {
	static lc_name() {
		return "RunnableWithFallbacks";
	}
	constructor(fields) {
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "runnable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "fallbacks", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.runnable = fields.runnable;
		this.fallbacks = fields.fallbacks;
	}
	*runnables() {
		yield this.runnable;
		for (const fallback of this.fallbacks) yield fallback;
	}
	async invoke(input, options) {
		const config = ensureConfig(options);
		const callbackManager_ = await getCallbackManagerForConfig(config);
		const { runId,...otherConfigFields } = config;
		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherConfigFields?.runName);
		const childConfig = patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
		const res = await AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
			let firstError;
			for (const runnable of this.runnables()) {
				config?.signal?.throwIfAborted();
				try {
					const output = await runnable.invoke(input, childConfig);
					await runManager?.handleChainEnd(_coerceToDict(output, "output"));
					return output;
				} catch (e) {
					if (firstError === void 0) firstError = e;
				}
			}
			if (firstError === void 0) throw new Error("No error stored at end of fallback.");
			await runManager?.handleChainError(firstError);
			throw firstError;
		});
		return res;
	}
	async *_streamIterator(input, options) {
		const config = ensureConfig(options);
		const callbackManager_ = await getCallbackManagerForConfig(config);
		const { runId,...otherConfigFields } = config;
		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherConfigFields?.runName);
		let firstError;
		let stream;
		for (const runnable of this.runnables()) {
			config?.signal?.throwIfAborted();
			const childConfig = patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
			try {
				const originalStream = await runnable.stream(input, childConfig);
				stream = consumeAsyncIterableInContext(childConfig, originalStream);
				break;
			} catch (e) {
				if (firstError === void 0) firstError = e;
			}
		}
		if (stream === void 0) {
			const error = firstError ?? new Error("No error stored at end of fallback.");
			await runManager?.handleChainError(error);
			throw error;
		}
		let output;
		try {
			for await (const chunk of stream) {
				yield chunk;
				try {
					output = output === void 0 ? output : concat(output, chunk);
				} catch (e) {
					output = void 0;
				}
			}
		} catch (e) {
			await runManager?.handleChainError(e);
			throw e;
		}
		await runManager?.handleChainEnd(_coerceToDict(output, "output"));
	}
	async batch(inputs, options, batchOptions) {
		if (batchOptions?.returnExceptions) throw new Error("Not implemented.");
		const configList = this._getOptionsList(options ?? {}, inputs.length);
		const callbackManagers = await Promise.all(configList.map((config) => getCallbackManagerForConfig(config)));
		const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
			const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, void 0, void 0, void 0, configList[i].runName);
			delete configList[i].runId;
			return handleStartRes;
		}));
		let firstError;
		for (const runnable of this.runnables()) {
			configList[0].signal?.throwIfAborted();
			try {
				const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => patchConfig(configList[j], { callbacks: runManager?.getChild() })), batchOptions);
				await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(outputs[i], "output"))));
				return outputs;
			} catch (e) {
				if (firstError === void 0) firstError = e;
			}
		}
		if (!firstError) throw new Error("No error stored at end of fallbacks.");
		await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(firstError)));
		throw firstError;
	}
};
function _coerceToRunnable(coerceable) {
	if (typeof coerceable === "function") return new RunnableLambda({ func: coerceable });
	else if (Runnable.isRunnable(coerceable)) return coerceable;
	else if (!Array.isArray(coerceable) && typeof coerceable === "object") {
		const runnables = {};
		for (const [key, value] of Object.entries(coerceable)) runnables[key] = _coerceToRunnable(value);
		return new RunnableMap({ steps: runnables });
	} else throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`);
}
/**
* A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
* @example
* ```typescript
* import {
*   RunnableAssign,
*   RunnableLambda,
*   RunnableParallel,
* } from "@langchain/core/runnables";
*
* const calculateAge = (x: { birthYear: number }): { age: number } => {
*   const currentYear = new Date().getFullYear();
*   return { age: currentYear - x.birthYear };
* };
*
* const createGreeting = (x: { name: string }): { greeting: string } => {
*   return { greeting: `Hello, ${x.name}!` };
* };
*
* const mapper = RunnableParallel.from({
*   age_step: RunnableLambda.from(calculateAge),
*   greeting_step: RunnableLambda.from(createGreeting),
* });
*
* const runnableAssign = new RunnableAssign({ mapper });
*
* const res = await runnableAssign.invoke({ name: "Alice", birthYear: 1990 });
*
* // { name: "Alice", birthYear: 1990, age_step: { age: 34 }, greeting_step: { greeting: "Hello, Alice!" } }
* ```
*/
var RunnableAssign = class extends Runnable {
	static lc_name() {
		return "RunnableAssign";
	}
	constructor(fields) {
		if (fields instanceof RunnableMap) fields = { mapper: fields };
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "mapper", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.mapper = fields.mapper;
	}
	async invoke(input, options) {
		const mapperResult = await this.mapper.invoke(input, options);
		return {
			...input,
			...mapperResult
		};
	}
	async *_transform(generator, runManager, options) {
		const mapperKeys = this.mapper.getStepsKeys();
		const [forPassthrough, forMapper] = atee(generator);
		const mapperOutput = this.mapper.transform(forMapper, patchConfig(options, { callbacks: runManager?.getChild() }));
		const firstMapperChunkPromise = mapperOutput.next();
		for await (const chunk of forPassthrough) {
			if (typeof chunk !== "object" || Array.isArray(chunk)) throw new Error(`RunnableAssign can only be used with objects as input, got ${typeof chunk}`);
			const filtered = Object.fromEntries(Object.entries(chunk).filter(([key]) => !mapperKeys.includes(key)));
			if (Object.keys(filtered).length > 0) yield filtered;
		}
		yield (await firstMapperChunkPromise).value;
		for await (const chunk of mapperOutput) yield chunk;
	}
	transform(generator, options) {
		return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
	}
	async stream(input, options) {
		async function* generator() {
			yield input;
		}
		const config = ensureConfig(options);
		const wrappedGenerator = new AsyncGeneratorWithSetup({
			generator: this.transform(generator(), config),
			config
		});
		await wrappedGenerator.setup;
		return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
	}
};
/**
* A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
* Useful for streaming, can be automatically created and chained by calling `runnable.pick();`.
* @example
* ```typescript
* import { RunnablePick } from "@langchain/core/runnables";
*
* const inputData = {
*   name: "John",
*   age: 30,
*   city: "New York",
*   country: "USA",
*   email: "john.doe@example.com",
*   phone: "+1234567890",
* };
*
* const basicInfoRunnable = new RunnablePick(["name", "city"]);
*
* // Example invocation
* const res = await basicInfoRunnable.invoke(inputData);
*
* // { name: 'John', city: 'New York' }
* ```
*/
var RunnablePick = class extends Runnable {
	static lc_name() {
		return "RunnablePick";
	}
	constructor(fields) {
		if (typeof fields === "string" || Array.isArray(fields)) fields = { keys: fields };
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "runnables"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "keys", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.keys = fields.keys;
	}
	async _pick(input) {
		if (typeof this.keys === "string") return input[this.keys];
		else {
			const picked = this.keys.map((key) => [key, input[key]]).filter((v) => v[1] !== void 0);
			return picked.length === 0 ? void 0 : Object.fromEntries(picked);
		}
	}
	async invoke(input, options) {
		return this._callWithConfig(this._pick.bind(this), input, options);
	}
	async *_transform(generator) {
		for await (const chunk of generator) {
			const picked = await this._pick(chunk);
			if (picked !== void 0) yield picked;
		}
	}
	transform(generator, options) {
		return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
	}
	async stream(input, options) {
		async function* generator() {
			yield input;
		}
		const config = ensureConfig(options);
		const wrappedGenerator = new AsyncGeneratorWithSetup({
			generator: this.transform(generator(), config),
			config
		});
		await wrappedGenerator.setup;
		return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
	}
};
var RunnableToolLike = class extends RunnableBinding {
	constructor(fields) {
		const sequence = RunnableSequence.from([RunnableLambda.from(async (input) => {
			let toolInput;
			if (_isToolCall(input)) try {
				toolInput = await this.schema.parseAsync(input.args);
			} catch (e) {
				throw new ToolInputParsingException(`Received tool input did not match expected schema`, JSON.stringify(input.args));
			}
			else toolInput = input;
			return toolInput;
		}).withConfig({ runName: `${fields.name}:parse_input` }), fields.bound]).withConfig({ runName: fields.name });
		super({
			bound: sequence,
			config: fields.config ?? {}
		});
		Object.defineProperty(this, "name", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "description", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "schema", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.name = fields.name;
		this.description = fields.description;
		this.schema = fields.schema;
	}
	static lc_name() {
		return "RunnableToolLike";
	}
};
/**
* Given a runnable and a Zod schema, convert the runnable to a tool.
*
* @template RunInput The input type for the runnable.
* @template RunOutput The output type for the runnable.
*
* @param {Runnable<RunInput, RunOutput>} runnable The runnable to convert to a tool.
* @param fields
* @param {string | undefined} [fields.name] The name of the tool. If not provided, it will default to the name of the runnable.
* @param {string | undefined} [fields.description] The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.
* @param {z.ZodType<RunInput>} [fields.schema] The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.
* @returns {RunnableToolLike<z.ZodType<RunInput>, RunOutput>} An instance of `RunnableToolLike` which is a runnable that can be used as a tool.
*/
function convertRunnableToTool(runnable, fields) {
	const name = fields.name ?? runnable.getName();
	const description = fields.description ?? fields.schema?.description;
	if (fields.schema.constructor === ZodString) return new RunnableToolLike({
		name,
		description,
		schema: objectType({ input: stringType() }).transform((input) => input.input),
		bound: runnable
	});
	return new RunnableToolLike({
		name,
		description,
		schema: fields.schema,
		bound: runnable
	});
}

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompt_values.js
var prompt_values_exports = {};
__export(prompt_values_exports, {
	BasePromptValue: () => BasePromptValue,
	ChatPromptValue: () => ChatPromptValue,
	ImagePromptValue: () => ImagePromptValue,
	StringPromptValue: () => StringPromptValue
});
/**
* Base PromptValue class. All prompt values should extend this class.
*/
var BasePromptValue = class extends Serializable {};
/**
* Represents a prompt value as a string. It extends the BasePromptValue
* class and overrides the toString and toChatMessages methods.
*/
var StringPromptValue = class extends BasePromptValue {
	static lc_name() {
		return "StringPromptValue";
	}
	constructor(value) {
		super({ value });
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "prompt_values"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "value", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.value = value;
	}
	toString() {
		return this.value;
	}
	toChatMessages() {
		return [new HumanMessage(this.value)];
	}
};
/**
* Class that represents a chat prompt value. It extends the
* BasePromptValue and includes an array of BaseMessage instances.
*/
var ChatPromptValue = class extends BasePromptValue {
	static lc_name() {
		return "ChatPromptValue";
	}
	constructor(fields) {
		if (Array.isArray(fields)) fields = { messages: fields };
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "prompt_values"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "messages", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.messages = fields.messages;
	}
	toString() {
		return getBufferString(this.messages);
	}
	toChatMessages() {
		return this.messages;
	}
};
/**
* Class that represents an image prompt value. It extends the
* BasePromptValue and includes an ImageURL instance.
*/
var ImagePromptValue = class extends BasePromptValue {
	static lc_name() {
		return "ImagePromptValue";
	}
	constructor(fields) {
		if (!("imageUrl" in fields)) fields = { imageUrl: fields };
		super(fields);
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: ["langchain_core", "prompt_values"]
		});
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "imageUrl", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/** @ignore */
		Object.defineProperty(this, "value", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		this.imageUrl = fields.imageUrl;
	}
	toString() {
		return this.imageUrl.url;
	}
	toChatMessages() {
		return [new HumanMessage({ content: [{
			type: "image_url",
			image_url: {
				detail: this.imageUrl.detail,
				url: this.imageUrl.url
			}
		}] })];
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/base.js
/**
* Base class for prompt templates. Exposes a format method that returns a
* string prompt given a set of input values.
*/
var BasePromptTemplate = class extends Runnable {
	get lc_attributes() {
		return { partialVariables: void 0 };
	}
	constructor(input) {
		super(input);
		Object.defineProperty(this, "lc_serializable", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		Object.defineProperty(this, "lc_namespace", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: [
				"langchain_core",
				"prompts",
				this._getPromptType()
			]
		});
		Object.defineProperty(this, "inputVariables", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "outputParser", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "partialVariables", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/**
		* Metadata to be used for tracing.
		*/
		Object.defineProperty(this, "metadata", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		/** Tags to be used for tracing. */
		Object.defineProperty(this, "tags", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		const { inputVariables } = input;
		if (inputVariables.includes("stop")) throw new Error("Cannot have an input variable named 'stop', as it is used internally, please rename.");
		Object.assign(this, input);
	}
	/**
	* Merges partial variables and user variables.
	* @param userVariables The user variables to merge with the partial variables.
	* @returns A Promise that resolves to an object containing the merged variables.
	*/
	async mergePartialAndUserVariables(userVariables) {
		const partialVariables = this.partialVariables ?? {};
		const partialValues = {};
		for (const [key, value] of Object.entries(partialVariables)) if (typeof value === "string") partialValues[key] = value;
		else partialValues[key] = await value();
		const allKwargs = {
			...partialValues,
			...userVariables
		};
		return allKwargs;
	}
	/**
	* Invokes the prompt template with the given input and options.
	* @param input The input to invoke the prompt template with.
	* @param options Optional configuration for the callback.
	* @returns A Promise that resolves to the output of the prompt template.
	*/
	async invoke(input, options) {
		const metadata = {
			...this.metadata,
			...options?.metadata
		};
		const tags = [...this.tags ?? [], ...options?.tags ?? []];
		return this._callWithConfig((input$1) => this.formatPromptValue(input$1), input, {
			...options,
			tags,
			metadata,
			runType: "prompt"
		});
	}
	/**
	* Return a json-like object representing this prompt template.
	* @deprecated
	*/
	serialize() {
		throw new Error("Use .toJSON() instead");
	}
	/**
	* @deprecated
	* Load a prompt template from a json-like object describing it.
	*
	* @remarks
	* Deserializing needs to be async because templates (e.g. {@link FewShotPromptTemplate}) can
	* reference remote resources that we read asynchronously with a web
	* request.
	*/
	static async deserialize(data) {
		switch (data._type) {
			case "prompt": {
				const { PromptTemplate: PromptTemplate$1 } = await import("./prompt-DoC83bWw.mjs");
				return PromptTemplate$1.deserialize(data);
			}
			case void 0: {
				const { PromptTemplate: PromptTemplate$1 } = await import("./prompt-DoC83bWw.mjs");
				return PromptTemplate$1.deserialize({
					...data,
					_type: "prompt"
				});
			}
			case "few_shot": {
				const { FewShotPromptTemplate } = await import("./few_shot-C9MZ9K-V.mjs");
				return FewShotPromptTemplate.deserialize(data);
			}
			default: throw new Error(`Invalid prompt type in config: ${data._type}`);
		}
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/string.js
/**
* Base class for string prompt templates. It extends the
* BasePromptTemplate class and overrides the formatPromptValue method to
* return a StringPromptValue.
*/
var BaseStringPromptTemplate = class extends BasePromptTemplate {
	/**
	* Formats the prompt given the input values and returns a formatted
	* prompt value.
	* @param values The input values to format the prompt.
	* @returns A Promise that resolves to a formatted prompt value.
	*/
	async formatPromptValue(values) {
		const formattedPrompt = await this.format(values);
		return new StringPromptValue(formattedPrompt);
	}
};

//#endregion
//#region node_modules/.pnpm/mustache@4.2.0/node_modules/mustache/mustache.mjs
/*!
* mustache.js - Logic-less {{mustache}} templates with JavaScript
* http://github.com/janl/mustache.js
*/
var objectToString = Object.prototype.toString;
var isArray = Array.isArray || function isArrayPolyfill(object) {
	return objectToString.call(object) === "[object Array]";
};
function isFunction(object) {
	return typeof object === "function";
}
/**
* More correct typeof string handling array
* which normally returns typeof 'object'
*/
function typeStr(obj) {
	return isArray(obj) ? "array" : typeof obj;
}
function escapeRegExp(string) {
	return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
}
/**
* Null safe way of checking whether or not an object,
* including its prototype, has a given property
*/
function hasProperty(obj, propName) {
	return obj != null && typeof obj === "object" && propName in obj;
}
/**
* Safe way of detecting whether or not the given thing is a primitive and
* whether it has the given property
*/
function primitiveHasOwnProperty(primitive, propName) {
	return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
}
var regExpTest = RegExp.prototype.test;
function testRegExp(re$5, string) {
	return regExpTest.call(re$5, string);
}
var nonSpaceRe = /\S/;
function isWhitespace(string) {
	return !testRegExp(nonSpaceRe, string);
}
var entityMap = {
	"&": "&amp;",
	"<": "&lt;",
	">": "&gt;",
	"\"": "&quot;",
	"'": "&#39;",
	"/": "&#x2F;",
	"`": "&#x60;",
	"=": "&#x3D;"
};
function escapeHtml(string) {
	return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap(s) {
		return entityMap[s];
	});
}
var whiteRe = /\s*/;
var spaceRe = /\s+/;
var equalsRe = /\s*=/;
var curlyRe = /\s*\}/;
var tagRe = /#|\^|\/|>|\{|&|=|!/;
/**
* Breaks up the given `template` string into a tree of tokens. If the `tags`
* argument is given here it must be an array with two string values: the
* opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of
* course, the default is to use mustaches (i.e. mustache.tags).
*
* A token is an array with at least 4 elements. The first element is the
* mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag
* did not contain a symbol (i.e. {{myValue}}) this element is "name". For
* all text that appears outside a symbol this element is "text".
*
* The second element of a token is its "value". For mustache tags this is
* whatever else was inside the tag besides the opening symbol. For text tokens
* this is the text itself.
*
* The third and fourth elements of the token are the start and end indices,
* respectively, of the token in the original template.
*
* Tokens that are the root node of a subtree contain two more elements: 1) an
* array of tokens in the subtree and 2) the index in the original template at
* which the closing tag for that section begins.
*
* Tokens for partials also contain two more elements: 1) a string value of
* indendation prior to that tag and 2) the index of that tag on that line -
* eg a value of 2 indicates the partial is the third tag on this line.
*/
function parseTemplate$1(template, tags) {
	if (!template) return [];
	var lineHasNonSpace = false;
	var sections = [];
	var tokens = [];
	var spaces = [];
	var hasTag = false;
	var nonSpace = false;
	var indentation = "";
	var tagIndex = 0;
	function stripSpace() {
		if (hasTag && !nonSpace) while (spaces.length) delete tokens[spaces.pop()];
		else spaces = [];
		hasTag = false;
		nonSpace = false;
	}
	var openingTagRe, closingTagRe, closingCurlyRe;
	function compileTags(tagsToCompile) {
		if (typeof tagsToCompile === "string") tagsToCompile = tagsToCompile.split(spaceRe, 2);
		if (!isArray(tagsToCompile) || tagsToCompile.length !== 2) throw new Error("Invalid tags: " + tagsToCompile);
		openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + "\\s*");
		closingTagRe = new RegExp("\\s*" + escapeRegExp(tagsToCompile[1]));
		closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + tagsToCompile[1]));
	}
	compileTags(tags || mustache.tags);
	var scanner = new Scanner(template);
	var start, type, value, chr, token, openSection;
	while (!scanner.eos()) {
		start = scanner.pos;
		value = scanner.scanUntil(openingTagRe);
		if (value) for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
			chr = value.charAt(i);
			if (isWhitespace(chr)) {
				spaces.push(tokens.length);
				indentation += chr;
			} else {
				nonSpace = true;
				lineHasNonSpace = true;
				indentation += " ";
			}
			tokens.push([
				"text",
				chr,
				start,
				start + 1
			]);
			start += 1;
			if (chr === "\n") {
				stripSpace();
				indentation = "";
				tagIndex = 0;
				lineHasNonSpace = false;
			}
		}
		if (!scanner.scan(openingTagRe)) break;
		hasTag = true;
		type = scanner.scan(tagRe) || "name";
		scanner.scan(whiteRe);
		if (type === "=") {
			value = scanner.scanUntil(equalsRe);
			scanner.scan(equalsRe);
			scanner.scanUntil(closingTagRe);
		} else if (type === "{") {
			value = scanner.scanUntil(closingCurlyRe);
			scanner.scan(curlyRe);
			scanner.scanUntil(closingTagRe);
			type = "&";
		} else value = scanner.scanUntil(closingTagRe);
		if (!scanner.scan(closingTagRe)) throw new Error("Unclosed tag at " + scanner.pos);
		if (type == ">") token = [
			type,
			value,
			start,
			scanner.pos,
			indentation,
			tagIndex,
			lineHasNonSpace
		];
		else token = [
			type,
			value,
			start,
			scanner.pos
		];
		tagIndex++;
		tokens.push(token);
		if (type === "#" || type === "^") sections.push(token);
		else if (type === "/") {
			openSection = sections.pop();
			if (!openSection) throw new Error("Unopened section \"" + value + "\" at " + start);
			if (openSection[1] !== value) throw new Error("Unclosed section \"" + openSection[1] + "\" at " + start);
		} else if (type === "name" || type === "{" || type === "&") nonSpace = true;
		else if (type === "=") compileTags(value);
	}
	stripSpace();
	openSection = sections.pop();
	if (openSection) throw new Error("Unclosed section \"" + openSection[1] + "\" at " + scanner.pos);
	return nestTokens(squashTokens(tokens));
}
/**
* Combines the values of consecutive text tokens in the given `tokens` array
* to a single token.
*/
function squashTokens(tokens) {
	var squashedTokens = [];
	var token, lastToken;
	for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
		token = tokens[i];
		if (token) if (token[0] === "text" && lastToken && lastToken[0] === "text") {
			lastToken[1] += token[1];
			lastToken[3] = token[3];
		} else {
			squashedTokens.push(token);
			lastToken = token;
		}
	}
	return squashedTokens;
}
/**
* Forms the given array of `tokens` into a nested tree structure where
* tokens that represent a section have two additional items: 1) an array of
* all tokens that appear in that section and 2) the index in the original
* template that represents the end of that section.
*/
function nestTokens(tokens) {
	var nestedTokens = [];
	var collector = nestedTokens;
	var sections = [];
	var token, section;
	for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
		token = tokens[i];
		switch (token[0]) {
			case "#":
			case "^":
				collector.push(token);
				sections.push(token);
				collector = token[4] = [];
				break;
			case "/":
				section = sections.pop();
				section[5] = token[2];
				collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
				break;
			default: collector.push(token);
		}
	}
	return nestedTokens;
}
/**
* A simple string scanner that is used by the template parser to find
* tokens in template strings.
*/
function Scanner(string) {
	this.string = string;
	this.tail = string;
	this.pos = 0;
}
/**
* Returns `true` if the tail is empty (end of string).
*/
Scanner.prototype.eos = function eos() {
	return this.tail === "";
};
/**
* Tries to match the given regular expression at the current position.
* Returns the matched text if it can match, the empty string otherwise.
*/
Scanner.prototype.scan = function scan(re$5) {
	var match = this.tail.match(re$5);
	if (!match || match.index !== 0) return "";
	var string = match[0];
	this.tail = this.tail.substring(string.length);
	this.pos += string.length;
	return string;
};
/**
* Skips all text until the given regular expression can be matched. Returns
* the skipped string, which is the entire tail if no match can be made.
*/
Scanner.prototype.scanUntil = function scanUntil(re$5) {
	var index = this.tail.search(re$5), match;
	switch (index) {
		case -1:
			match = this.tail;
			this.tail = "";
			break;
		case 0:
			match = "";
			break;
		default:
			match = this.tail.substring(0, index);
			this.tail = this.tail.substring(index);
	}
	this.pos += match.length;
	return match;
};
/**
* Represents a rendering context by wrapping a view object and
* maintaining a reference to the parent context.
*/
function Context(view, parentContext) {
	this.view = view;
	this.cache = { ".": this.view };
	this.parent = parentContext;
}
/**
* Creates a new context using the given view with this context
* as the parent.
*/
Context.prototype.push = function push(view) {
	return new Context(view, this);
};
/**
* Returns the value of the given name in this context, traversing
* up the context hierarchy if the value is absent in this context's view.
*/
Context.prototype.lookup = function lookup(name) {
	var cache$1 = this.cache;
	var value;
	if (cache$1.hasOwnProperty(name)) value = cache$1[name];
	else {
		var context = this, intermediateValue, names, index, lookupHit = false;
		while (context) {
			if (name.indexOf(".") > 0) {
				intermediateValue = context.view;
				names = name.split(".");
				index = 0;
				/**
				* Using the dot notion path in `name`, we descend through the
				* nested objects.
				*
				* To be certain that the lookup has been successful, we have to
				* check if the last object in the path actually has the property
				* we are looking for. We store the result in `lookupHit`.
				*
				* This is specially necessary for when the value has been set to
				* `undefined` and we want to avoid looking up parent contexts.
				*
				* In the case where dot notation is used, we consider the lookup
				* to be successful even if the last "object" in the path is
				* not actually an object but a primitive (e.g., a string, or an
				* integer), because it is sometimes useful to access a property
				* of an autoboxed primitive, such as the length of a string.
				**/
				while (intermediateValue != null && index < names.length) {
					if (index === names.length - 1) lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
					intermediateValue = intermediateValue[names[index++]];
				}
			} else {
				intermediateValue = context.view[name];
				/**
				* Only checking against `hasProperty`, which always returns `false` if
				* `context.view` is not an object. Deliberately omitting the check
				* against `primitiveHasOwnProperty` if dot notation is not used.
				*
				* Consider this example:
				* ```
				* Mustache.render("The length of a football field is {{#length}}{{length}}{{/length}}.", {length: "100 yards"})
				* ```
				*
				* If we were to check also against `primitiveHasOwnProperty`, as we do
				* in the dot notation case, then render call would return:
				*
				* "The length of a football field is 9."
				*
				* rather than the expected:
				*
				* "The length of a football field is 100 yards."
				**/
				lookupHit = hasProperty(context.view, name);
			}
			if (lookupHit) {
				value = intermediateValue;
				break;
			}
			context = context.parent;
		}
		cache$1[name] = value;
	}
	if (isFunction(value)) value = value.call(this.view);
	return value;
};
/**
* A Writer knows how to take a stream of tokens and render them to a
* string, given a context. It also maintains a cache of templates to
* avoid the need to parse the same template twice.
*/
function Writer() {
	this.templateCache = {
		_cache: {},
		set: function set(key, value) {
			this._cache[key] = value;
		},
		get: function get(key) {
			return this._cache[key];
		},
		clear: function clear() {
			this._cache = {};
		}
	};
}
/**
* Clears all cached templates in this writer.
*/
Writer.prototype.clearCache = function clearCache() {
	if (typeof this.templateCache !== "undefined") this.templateCache.clear();
};
/**
* Parses and caches the given `template` according to the given `tags` or
* `mustache.tags` if `tags` is omitted,  and returns the array of tokens
* that is generated from the parse.
*/
Writer.prototype.parse = function parse$7(template, tags) {
	var cache$1 = this.templateCache;
	var cacheKey = template + ":" + (tags || mustache.tags).join(":");
	var isCacheEnabled = typeof cache$1 !== "undefined";
	var tokens = isCacheEnabled ? cache$1.get(cacheKey) : void 0;
	if (tokens == void 0) {
		tokens = parseTemplate$1(template, tags);
		isCacheEnabled && cache$1.set(cacheKey, tokens);
	}
	return tokens;
};
/**
* High-level method that is used to render the given `template` with
* the given `view`.
*
* The optional `partials` argument may be an object that contains the
* names and templates of partials that are used in the template. It may
* also be a function that is used to load partial templates on the fly
* that takes a single argument: the name of the partial.
*
* If the optional `config` argument is given here, then it should be an
* object with a `tags` attribute or an `escape` attribute or both.
* If an array is passed, then it will be interpreted the same way as
* a `tags` attribute on a `config` object.
*
* The `tags` attribute of a `config` object must be an array with two
* string values: the opening and closing tags used in the template (e.g.
* [ "<%", "%>" ]). The default is to mustache.tags.
*
* The `escape` attribute of a `config` object must be a function which
* accepts a string as input and outputs a safely escaped string.
* If an `escape` function is not provided, then an HTML-safe string
* escaping function is used as the default.
*/
Writer.prototype.render = function render(template, view, partials, config) {
	var tags = this.getConfigTags(config);
	var tokens = this.parse(template, tags);
	var context = view instanceof Context ? view : new Context(view, void 0);
	return this.renderTokens(tokens, context, partials, template, config);
};
/**
* Low-level method that renders the given array of `tokens` using
* the given `context` and `partials`.
*
* Note: The `originalTemplate` is only ever used to extract the portion
* of the original template that was contained in a higher-order section.
* If the template doesn't use higher-order sections, this argument may
* be omitted.
*/
Writer.prototype.renderTokens = function renderTokens(tokens, context, partials, originalTemplate, config) {
	var buffer = "";
	var token, symbol, value;
	for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
		value = void 0;
		token = tokens[i];
		symbol = token[0];
		if (symbol === "#") value = this.renderSection(token, context, partials, originalTemplate, config);
		else if (symbol === "^") value = this.renderInverted(token, context, partials, originalTemplate, config);
		else if (symbol === ">") value = this.renderPartial(token, context, partials, config);
		else if (symbol === "&") value = this.unescapedValue(token, context);
		else if (symbol === "name") value = this.escapedValue(token, context, config);
		else if (symbol === "text") value = this.rawValue(token);
		if (value !== void 0) buffer += value;
	}
	return buffer;
};
Writer.prototype.renderSection = function renderSection(token, context, partials, originalTemplate, config) {
	var self = this;
	var buffer = "";
	var value = context.lookup(token[1]);
	function subRender(template) {
		return self.render(template, context, partials, config);
	}
	if (!value) return;
	if (isArray(value)) for (var j = 0, valueLength = value.length; j < valueLength; ++j) buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);
	else if (typeof value === "object" || typeof value === "string" || typeof value === "number") buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);
	else if (isFunction(value)) {
		if (typeof originalTemplate !== "string") throw new Error("Cannot use higher-order sections without the original template");
		value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
		if (value != null) buffer += value;
	} else buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);
	return buffer;
};
Writer.prototype.renderInverted = function renderInverted(token, context, partials, originalTemplate, config) {
	var value = context.lookup(token[1]);
	if (!value || isArray(value) && value.length === 0) return this.renderTokens(token[4], context, partials, originalTemplate, config);
};
Writer.prototype.indentPartial = function indentPartial(partial, indentation, lineHasNonSpace) {
	var filteredIndentation = indentation.replace(/[^ \t]/g, "");
	var partialByNl = partial.split("\n");
	for (var i = 0; i < partialByNl.length; i++) if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) partialByNl[i] = filteredIndentation + partialByNl[i];
	return partialByNl.join("\n");
};
Writer.prototype.renderPartial = function renderPartial(token, context, partials, config) {
	if (!partials) return;
	var tags = this.getConfigTags(config);
	var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
	if (value != null) {
		var lineHasNonSpace = token[6];
		var tagIndex = token[5];
		var indentation = token[4];
		var indentedValue = value;
		if (tagIndex == 0 && indentation) indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
		var tokens = this.parse(indentedValue, tags);
		return this.renderTokens(tokens, context, partials, indentedValue, config);
	}
};
Writer.prototype.unescapedValue = function unescapedValue(token, context) {
	var value = context.lookup(token[1]);
	if (value != null) return value;
};
Writer.prototype.escapedValue = function escapedValue(token, context, config) {
	var escape = this.getConfigEscape(config) || mustache.escape;
	var value = context.lookup(token[1]);
	if (value != null) return typeof value === "number" && escape === mustache.escape ? String(value) : escape(value);
};
Writer.prototype.rawValue = function rawValue(token) {
	return token[1];
};
Writer.prototype.getConfigTags = function getConfigTags(config) {
	if (isArray(config)) return config;
	else if (config && typeof config === "object") return config.tags;
	else return void 0;
};
Writer.prototype.getConfigEscape = function getConfigEscape(config) {
	if (config && typeof config === "object" && !isArray(config)) return config.escape;
	else return void 0;
};
var mustache = {
	name: "mustache.js",
	version: "4.2.0",
	tags: ["{{", "}}"],
	clearCache: void 0,
	escape: void 0,
	parse: void 0,
	render: void 0,
	Scanner: void 0,
	Context: void 0,
	Writer: void 0,
	set templateCache(cache$1) {
		defaultWriter.templateCache = cache$1;
	},
	get templateCache() {
		return defaultWriter.templateCache;
	}
};
var defaultWriter = new Writer();
/**
* Clears all cached templates in the default writer.
*/
mustache.clearCache = function clearCache() {
	return defaultWriter.clearCache();
};
/**
* Parses and caches the given template in the default writer and returns the
* array of tokens it contains. Doing this ahead of time avoids the need to
* parse templates on the fly as they are rendered.
*/
mustache.parse = function parse$7(template, tags) {
	return defaultWriter.parse(template, tags);
};
/**
* Renders the `template` with the given `view`, `partials`, and `config`
* using the default writer.
*/
mustache.render = function render(template, view, partials, config) {
	if (typeof template !== "string") throw new TypeError("Invalid template! Template should be a \"string\" but \"" + typeStr(template) + "\" was given as the first argument for mustache#render(template, view, partials)");
	return defaultWriter.render(template, view, partials, config);
};
mustache.escape = escapeHtml;
mustache.Scanner = Scanner;
mustache.Context = Context;
mustache.Writer = Writer;
var mustache_default = mustache;

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/template.js
function configureMustache() {
	mustache_default.escape = (text) => text;
}
const parseFString = (template) => {
	const chars = template.split("");
	const nodes = [];
	const nextBracket = (bracket, start) => {
		for (let i$1 = start; i$1 < chars.length; i$1 += 1) if (bracket.includes(chars[i$1])) return i$1;
		return -1;
	};
	let i = 0;
	while (i < chars.length) if (chars[i] === "{" && i + 1 < chars.length && chars[i + 1] === "{") {
		nodes.push({
			type: "literal",
			text: "{"
		});
		i += 2;
	} else if (chars[i] === "}" && i + 1 < chars.length && chars[i + 1] === "}") {
		nodes.push({
			type: "literal",
			text: "}"
		});
		i += 2;
	} else if (chars[i] === "{") {
		const j = nextBracket("}", i);
		if (j < 0) throw new Error("Unclosed '{' in template.");
		nodes.push({
			type: "variable",
			name: chars.slice(i + 1, j).join("")
		});
		i = j + 1;
	} else if (chars[i] === "}") throw new Error("Single '}' in template.");
	else {
		const next = nextBracket("{}", i);
		const text = (next < 0 ? chars.slice(i) : chars.slice(i, next)).join("");
		nodes.push({
			type: "literal",
			text
		});
		i = next < 0 ? chars.length : next;
	}
	return nodes;
};
/**
* Convert the result of mustache.parse into an array of ParsedTemplateNode,
* to make it compatible with other LangChain string parsing template formats.
*
* @param {mustache.TemplateSpans} template The result of parsing a mustache template with the mustache.js library.
* @returns {ParsedTemplateNode[]}
*/
const mustacheTemplateToNodes = (template) => template.map((temp) => {
	if (temp[0] === "name") {
		const name = temp[1].includes(".") ? temp[1].split(".")[0] : temp[1];
		return {
			type: "variable",
			name
		};
	} else if ([
		"#",
		"&",
		"^",
		">"
	].includes(temp[0])) return {
		type: "variable",
		name: temp[1]
	};
	else return {
		type: "literal",
		text: temp[1]
	};
});
const parseMustache = (template) => {
	configureMustache();
	const parsed = mustache_default.parse(template);
	return mustacheTemplateToNodes(parsed);
};
const interpolateFString = (template, values) => {
	return parseFString(template).reduce((res, node) => {
		if (node.type === "variable") {
			if (node.name in values) {
				const stringValue = typeof values[node.name] === "string" ? values[node.name] : JSON.stringify(values[node.name]);
				return res + stringValue;
			}
			throw new Error(`(f-string) Missing value for input ${node.name}`);
		}
		return res + node.text;
	}, "");
};
const interpolateMustache = (template, values) => {
	configureMustache();
	return mustache_default.render(template, values);
};
const DEFAULT_FORMATTER_MAPPING = {
	"f-string": interpolateFString,
	mustache: interpolateMustache
};
const DEFAULT_PARSER_MAPPING = {
	"f-string": parseFString,
	mustache: parseMustache
};
const renderTemplate = (template, templateFormat, inputValues) => {
	try {
		return DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues);
	} catch (e) {
		const error = addLangChainErrorFields(e, "INVALID_PROMPT_INPUT");
		throw error;
	}
};
const parseTemplate = (template, templateFormat) => DEFAULT_PARSER_MAPPING[templateFormat](template);
const checkValidTemplate = (template, templateFormat, inputVariables) => {
	if (!(templateFormat in DEFAULT_FORMATTER_MAPPING)) {
		const validFormats = Object.keys(DEFAULT_FORMATTER_MAPPING);
		throw new Error(`Invalid template format. Got \`${templateFormat}\`;
                         should be one of ${validFormats}`);
	}
	try {
		const dummyInputs = inputVariables.reduce((acc, v) => {
			acc[v] = "foo";
			return acc;
		}, {});
		if (Array.isArray(template)) template.forEach((message) => {
			if (message.type === "text") renderTemplate(message.text, templateFormat, dummyInputs);
			else if (message.type === "image_url") if (typeof message.image_url === "string") renderTemplate(message.image_url, templateFormat, dummyInputs);
			else {
				const imageUrl = message.image_url.url;
				renderTemplate(imageUrl, templateFormat, dummyInputs);
			}
			else throw new Error(`Invalid message template received. ${JSON.stringify(message, null, 2)}`);
		});
		else renderTemplate(template, templateFormat, dummyInputs);
	} catch (e) {
		throw new Error(`Invalid prompt schema: ${e.message}`);
	}
};

//#endregion
//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/prompt.js
/**
* Schema to represent a basic prompt for an LLM.
* @augments BasePromptTemplate
* @augments PromptTemplateInput
*
* @example
* ```ts
* import { PromptTemplate } from "langchain/prompts";
*
* const prompt = new PromptTemplate({
*   inputVariables: ["foo"],
*   template: "Say {foo}",
* });
* ```
*/
var PromptTemplate = class PromptTemplate extends BaseStringPromptTemplate {
	static lc_name() {
		return "PromptTemplate";
	}
	constructor(input) {
		super(input);
		Object.defineProperty(this, "template", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		Object.defineProperty(this, "templateFormat", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: "f-string"
		});
		Object.defineProperty(this, "validateTemplate", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: true
		});
		/**
		* Additional fields which should be included inside
		* the message content array if using a complex message
		* content.
		*/
		Object.defineProperty(this, "additionalContentFields", {
			enumerable: true,
			configurable: true,
			writable: true,
			value: void 0
		});
		if (input.templateFormat === "mustache" && input.validateTemplate === void 0) this.validateTemplate = false;
		Object.assign(this, input);
		if (this.validateTemplate) {
			if (this.templateFormat === "mustache") throw new Error("Mustache templates cannot be validated.");
			let totalInputVariables = this.inputVariables;
			if (this.partialVariables) totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables));
			checkValidTemplate(this.template, this.templateFormat, totalInputVariables);
		}
	}
	_getPromptType() {
		return "prompt";
	}
	/**
	* Formats the prompt template with the provided values.
	* @param values The values to be used to format the prompt template.
	* @returns A promise that resolves to a string which is the formatted prompt.
	*/
	async format(values) {
		const allValues = await this.mergePartialAndUserVariables(values);
		return renderTemplate(this.template, this.templateFormat, allValues);
	}
	/**
	* Take examples in list format with prefix and suffix to create a prompt.
	*
	* Intended to be used a a way to dynamically create a prompt from examples.
	*
	* @param examples - List of examples to use in the prompt.
	* @param suffix - String to go after the list of examples. Should generally set up the user's input.
	* @param inputVariables - A list of variable names the final prompt template will expect
	* @param exampleSeparator - The separator to use in between examples
	* @param prefix - String that should go before any examples. Generally includes examples.
	*
	* @returns The final prompt template generated.
	*/
	static fromExamples(examples, suffix, inputVariables, exampleSeparator = "\n\n", prefix$1 = "") {
		const template = [
			prefix$1,
			...examples,
			suffix
		].join(exampleSeparator);
		return new PromptTemplate({
			inputVariables,
			template
		});
	}
	static fromTemplate(template, options) {
		const { templateFormat = "f-string",...rest } = options ?? {};
		const names = /* @__PURE__ */ new Set();
		parseTemplate(template, templateFormat).forEach((node) => {
			if (node.type === "variable") names.add(node.name);
		});
		return new PromptTemplate({
			inputVariables: [...names],
			templateFormat,
			template,
			...rest
		});
	}
	/**
	* Partially applies values to the prompt template.
	* @param values The values to be partially applied to the prompt template.
	* @returns A new instance of PromptTemplate with the partially applied values.
	*/
	async partial(values) {
		const newInputVariables = this.inputVariables.filter((iv) => !(iv in values));
		const newPartialVariables = {
			...this.partialVariables ?? {},
			...values
		};
		const promptDict = {
			...this,
			inputVariables: newInputVariables,
			partialVariables: newPartialVariables
		};
		return new PromptTemplate(promptDict);
	}
	serialize() {
		if (this.outputParser !== void 0) throw new Error("Cannot serialize a prompt template with an output parser");
		return {
			_type: this._getPromptType(),
			input_variables: this.inputVariables,
			template: this.template,
			template_format: this.templateFormat
		};
	}
	static async deserialize(data) {
		if (!data.template) throw new Error("Prompt template must have a template");
		const res = new PromptTemplate({
			inputVariables: data.input_variables,
			template: data.template,
			templateFormat: data.template_format
		});
		return res;
	}
};

//#endregion
export { AIMessage, AIMessageChunk, AsyncCaller, AsyncLocalStorageProviderSingleton, BaseCallbackHandler, BaseMessage, BaseMessageChunk, BasePromptTemplate, BaseStringPromptTemplate, BaseTracer, CallbackManager, ChatGenerationChunk, ChatMessage, ChatMessageChunk, ChatPromptValue, DEFAULT_FORMATTER_MAPPING, DEFAULT_PARSER_MAPPING, FunctionMessage, FunctionMessageChunk, GenerationChunk, Graph, HumanMessage, HumanMessageChunk, ImagePromptValue, IterableReadableStream, LangChainTracer, PromptTemplate, RUN_KEY, Runnable, RunnableAssign, RunnableBinding, RunnableEach, RunnableLambda, RunnableMap, RunnableParallel, RunnablePick, RunnableRetry, RunnableSequence, RunnableToolLike, RunnableWithFallbacks, Serializable, StringPromptValue, SystemMessage, SystemMessageChunk, ToolInputParsingException, ToolMessage, ToolMessageChunk, ZodFirstPartyTypeKind, _coerceToDict, _coerceToRunnable, _configHasToolCallId, _isMessageFieldWithRole, _isToolCall, _mergeDicts, _mergeLists, _mergeObj, _mergeStatus, addLangChainErrorFields, anyType, applyPatch, arrayType, async_caller_exports, base_exports, base_exports$1, booleanType, callbackHandlerPrefersStreaming, checkValidTemplate, coerceMessageLikeToMessage, compare, concat, console_exports, convertToChunk, convertToOpenAIImageBlock, convertToProviderContentBlock, custom, ensureConfig, enumType, env_exports, getBufferString, getCallbackManagerForConfig, getEnvironmentVariable, get_lc_unique_name, interpolateFString, interpolateMustache, isAIMessage, isAIMessageChunk, isBase64ContentBlock, isBaseMessage, isBaseMessageChunk, isChatMessage, isChatMessageChunk, isDataContentBlock, isDirectToolOutput, isFunctionMessage, isFunctionMessageChunk, isHumanMessage, isHumanMessageChunk, isIDContentBlock, isOpenAIToolCallArray, isPlainTextContentBlock, isSystemMessage, isSystemMessageChunk, isToolMessage, isToolMessageChunk, isURLContentBlock, keyFromJson, log_stream_exports, manager_exports, mapChatMessagesToStoredMessages, mapKeys, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages, mergeConfigs, mergeContent, numberType, objectType, outputs_exports, parseBase64DataUrl, parseCallbackConfigArg, parseFString, parseJsonMarkdown, parseMimeType, parseMustache, parsePartialJson, parseTemplate, patchConfig, pickRunnableConfigKeys, promises_exports, prompt_values_exports, renderTemplate, rng, serializable_exports, stream_exports, stringType, tracer_langchain_exports, unsafeStringify, v4_default, validate_default, zodToJsonSchema };