@mastra/mcp 1.17.3 → 1.18.0-alpha.1

package/dist/index.cjs

@@ -9830,11 +9830,11 @@ var AiSdkSchemaWrapper = class {
 * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });
 * ```
 */
-function toStandardSchema$4(schema) {
+function toStandardSchema$5(schema) {
 	return new AiSdkSchemaWrapper(schema);
 }
 //#endregion
-//#region ../schema-compat/dist/json-schema-BstKYbJi.js
+//#region ../schema-compat/dist/json-schema-BKit3LVN.js
 var require_code$1 = /* @__PURE__ */ __commonJSMin$1(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
@@ -12440,11 +12440,27 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	/** @type {(value: string) => boolean} */
 	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
 	/** @type {(value: string) => boolean} */
+	const isPort = RegExp.prototype.test.bind(/^\d*$/u);
+	/** @type {(value: string) => boolean} */
 	const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
 	/** @type {(value: string) => boolean} */
 	const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
 	/** @type {(value: string) => boolean} */
-	const isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+	const isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+	/** @type {(value: string) => boolean} */
+	const isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+	/** @type {(value: string) => boolean} */
+	const isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+	const BYTE_HEX = new Array(256);
+	{
+		const HEX_DIGITS = "0123456789ABCDEF";
+		for (let i = 0; i < 256; i++) BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+	}
+	function percentEncodeNonAscii(cp) {
+		if (cp < 2048) return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+		if (cp < 65536) return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+		return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+	}
 	/**
 	* @param {Array<string>} input
 	* @returns {string}
@@ -12467,119 +12483,162 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 		}
 		return acc;
 	}
-	/**
-	* @typedef {Object} GetIPV6Result
-	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
-	* @property {string} address - The parsed IPv6 address.
-	* @property {string} [zone] - The zone identifier, if present.
-	*/
+	/** @type {(value: string) => boolean} */
+	const isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+	/** @type {(value: string) => boolean} */
+	const isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+	/** @type {(value: string) => boolean} */
+	const isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
 	/**
 	* @param {string} value
 	* @returns {boolean}
 	*/
 	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
 	/**
-	* @param {Array<string>} buffer
+	* @param {string} zone
 	* @returns {boolean}
 	*/
-	function consumeIsZone(buffer) {
-		buffer.length = 0;
+	function isZoneIdentifier(zone) {
+		if (zone.length === 0) return false;
+		for (let i = 0; i < zone.length; i++) {
+			if (isZoneCharacter(zone[i])) continue;
+			if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+				i += 2;
+				continue;
+			}
+			return false;
+		}
 		return true;
 	}
 	/**
-	* @param {Array<string>} buffer
-	* @param {Array<string>} address
-	* @param {GetIPV6Result} output
-	* @returns {boolean}
+	* Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
+	* single zero hextet is left uncompressed. On ties the leftmost run wins.
+	*
+	* @param {string[]} hextets
+	* @returns {string}
 	*/
-	function consumeHextets(buffer, address, output) {
-		if (buffer.length) {
-			const hex = stringArrayToHexStripped(buffer);
-			if (hex !== "") address.push(hex);
-			else {
-				output.error = true;
-				return false;
+	function compressIPv6ZeroRun(hextets) {
+		let bestStart = -1;
+		let bestLength = 0;
+		let runStart = -1;
+		let runLength = 0;
+		for (let i = 0; i < hextets.length; i++) if (hextets[i] === "0") {
+			if (runStart === -1) runStart = i;
+			runLength++;
+			if (runLength > bestLength) {
+				bestLength = runLength;
+				bestStart = runStart;
 			}
-			buffer.length = 0;
+		} else {
+			runStart = -1;
+			runLength = 0;
 		}
-		return true;
+		if (bestLength < 2) return hextets.join(":");
+		const head = hextets.slice(0, bestStart).join(":");
+		const tail = hextets.slice(bestStart + bestLength).join(":");
+		return head + "::" + tail;
 	}
 	/**
+	* Validates an IPv6 address against the alternatives in RFC 3986 section
+	* 3.2.2 and returns the same address with leading hextet zeroes removed.
+	* An embedded IPv4 address counts as two hextets and is only valid at the end.
+	*
 	* @param {string} input
-	* @returns {GetIPV6Result}
+	* @returns {string|undefined}
 	*/
-	function getIPV6(input) {
-		let tokenCount = 0;
-		const output = {
-			error: false,
-			address: "",
-			zone: ""
-		};
-		/** @type {Array<string>} */
-		const address = [];
-		/** @type {Array<string>} */
-		const buffer = [];
-		let endipv6Encountered = false;
-		let endIpv6 = false;
-		let consume = consumeHextets;
-		for (let i = 0; i < input.length; i++) {
-			const cursor = input[i];
-			if (cursor === "[" || cursor === "]") continue;
-			if (cursor === ":") {
-				if (endipv6Encountered === true) endIpv6 = true;
-				if (!consume(buffer, address, output)) break;
-				if (++tokenCount > 7) {
-					output.error = true;
-					break;
-				}
-				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
-				address.push(":");
-				continue;
-			} else if (cursor === "%") {
-				if (!consume(buffer, address, output)) break;
-				consume = consumeIsZone;
-			} else {
-				buffer.push(cursor);
+	function normalizeIPv6Address(input) {
+		const compression = input.indexOf("::");
+		if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+		const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+		const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+		if (compression !== -1) {
+			if (left.length === 1 && left[0] === "") left.length = 0;
+			if (right.length === 1 && right[0] === "") right.length = 0;
+		}
+		const parts = left.concat(right);
+		let hextetCount = 0;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (part === "") return void 0;
+			if (part.indexOf(".") !== -1) {
+				if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+				hextetCount += 2;
 				continue;
 			}
+			if (!isHextet(part)) return void 0;
+			parts[i] = parseInt(part, 16).toString(16);
+			hextetCount++;
 		}
-		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
-		else if (endIpv6) address.push(buffer.join(""));
-		else address.push(stringArrayToHexStripped(buffer));
-		output.address = address.join("");
-		return output;
+		if (compression === -1) {
+			if (hextetCount !== 8) return void 0;
+			return compressIPv6ZeroRun(parts);
+		}
+		if (hextetCount >= 8) return void 0;
+		const expanded = parts.slice(0, left.length);
+		for (let i = hextetCount; i < 8; i++) expanded.push("0");
+		for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+		return compressIPv6ZeroRun(expanded);
 	}
 	/**
 	* @typedef {Object} NormalizeIPv6Result
 	* @property {string} host - The normalized host.
 	* @property {string} [escapedHost] - The escaped host.
 	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	* @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
+	* @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
 	*/
 	/**
+	* Validates and normalizes a bracketed IP literal. Raw zone separators remain
+	* accepted for backwards compatibility, while encoded separators and zone
+	* contents follow RFC 6874.
+	*
 	* @param {string} host
 	* @returns {NormalizeIPv6Result}
 	*/
 	function normalizeIPv6(host) {
-		if (findToken(host, ":") < 2) return {
+		const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+		if ((host[0] === "[" || host[host.length - 1] === "]") && !bracketed) return {
 			host,
-			isIPV6: false
+			isIPV6: false,
+			error: true
 		};
-		const ipv6 = getIPV6(host);
-		if (!ipv6.error) {
-			let newHost = ipv6.address;
-			let escapedHost = ipv6.address;
-			if (ipv6.zone) {
-				newHost += "%" + ipv6.zone;
-				escapedHost += "%25" + ipv6.zone;
-			}
+		let input = bracketed ? host.slice(1, -1) : host;
+		if (bracketed && isIPvFuture(input)) {
+			input = input.toLowerCase();
 			return {
-				host: newHost,
-				isIPV6: true,
-				escapedHost
+				host: `[${input}]`,
+				escapedHost: input,
+				isIPV6: false,
+				isIPVFuture: true
+			};
+		}
+		if (findToken(input, ":") < 2) return {
+			host,
+			isIPV6: false,
+			error: bracketed
+		};
+		let zoneIdentifier = "";
+		const zoneSeparator = input.indexOf("%");
+		if (zoneSeparator !== -1) {
+			const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+			zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+			if (!isZoneIdentifier(zoneIdentifier)) return {
+				host,
+				isIPV6: false,
+				error: true
 			};
-		} else return {
+			input = input.slice(0, zoneSeparator);
+		}
+		const address = normalizeIPv6Address(input);
+		if (address === void 0) return {
 			host,
-			isIPV6: false
+			isIPV6: false,
+			error: true
+		};
+		return {
+			host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+			escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+			isIPV6: true
 		};
 	}
 	/**
@@ -12692,7 +12751,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	}
 	/**
 	* Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
-	* Reserved delimiters such as `%2F` and `%2E` stay escaped.
+	* Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
 	*
 	* @param {string} input
 	* @param {boolean} [decodeUnreserved=false]
@@ -12728,7 +12787,8 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	function normalizePathEncoding(input) {
 		let output = "";
 		for (let i = 0; i < input.length; i++) {
-			if (input[i] === "%" && i + 2 < input.length) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
 				const hex = input.slice(i + 1, i + 3);
 				if (isHexPair(hex)) {
 					const normalizedHex = hex.toUpperCase();
@@ -12739,8 +12799,168 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 					continue;
 				}
 			}
-			if (isPathCharacter(input[i])) output += input[i];
-			else output += escape(input[i]);
+			if (isPathCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Serializes a path without rewriting reserved data. Raw RFC 3986 path
+	* characters remain literal, valid escapes are preserved and uppercased, and
+	* everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
+	* first segment must be escaped so the result cannot be parsed as a scheme.
+	*
+	* @param {string} input
+	* @param {boolean} [pathNoScheme=false]
+	* @returns {string}
+	*/
+	function serializePathEncoding(input, pathNoScheme = false) {
+		let output = "";
+		let firstSegment = pathNoScheme && input[0] !== "/";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			if (ch === "/") firstSegment = false;
+			if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Percent-encodes a URI component using its RFC 3986 literal character set.
+	* Existing valid escapes are preserved and normalized to uppercase hex.
+	*
+	* @param {string} input
+	* @param {(value: string) => boolean} isAllowed
+	* @returns {string}
+	*/
+	function encodeComponent(input, isAllowed) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			if (isAllowed(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
+	* In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeUserinfo(input) {
+		return encodeComponent(input, isUserinfoCharacter);
+	}
+	/**
+	* Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
+	* escaped because it would otherwise begin the fragment component.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeQuery(input) {
+		return encodeComponent(input, isQueryFragmentCharacter);
+	}
+	/**
+	* Encodes fragment data using the RFC 3986 §3.5 grammar.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeFragment(input) {
+		return encodeComponent(input, isQueryFragmentCharacter);
+	}
+	function isEscapeSafe(cp) {
+		return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+	}
+	/**
+	* Normalizes the percent-encoding of a query or fragment component.
+	*
+	* Like `normalizePathEncoding`, but uses the query/fragment character set
+	* (which additionally allows `?`) and decodes `.` since it has no dot-segment
+	* meaning outside of a path.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizeQueryFragmentEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isQueryFragmentCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
 		}
 		return output;
 	}
@@ -12772,21 +12992,27 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	function recomposeAuthority(component) {
 		const uriTokens = [];
 		if (component.userinfo !== void 0) {
-			uriTokens.push(component.userinfo);
+			uriTokens.push(encodeUserinfo(component.userinfo));
 			uriTokens.push("@");
 		}
 		if (component.host !== void 0) {
-			let host = unescape(component.host);
+			let host = component.host;
 			if (!isIPv4(host)) {
-				const ipV6res = normalizeIPv6(host);
-				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
+				let ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+					host = normalizePercentEncoding(host, true);
+					ipV6res = normalizeIPv6(host);
+				}
+				if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) host = `[${ipV6res.escapedHost}]`;
 				else host = reescapeHostDelimiters(host, false);
 			}
 			uriTokens.push(host);
 		}
 		if (typeof component.port === "number" || typeof component.port === "string") {
+			const port = String(component.port);
+			if (!isPort(port)) throw new TypeError("URI port is malformed.");
 			uriTokens.push(":");
-			uriTokens.push(String(component.port));
+			uriTokens.push(port);
 		}
 		return uriTokens.length ? uriTokens.join("") : void 0;
 	}
@@ -12796,6 +13022,11 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 		reescapeHostDelimiters,
 		normalizePercentEncoding,
 		normalizePathEncoding,
+		serializePathEncoding,
+		normalizeQueryFragmentEncoding,
+		encodeUserinfo,
+		encodeQuery,
+		encodeFragment,
 		escapePreservingEscapes,
 		removeDotSegments,
 		isIPv4,
@@ -12806,7 +13037,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 }));
 var require_schemes = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	const { isUUID } = require_utils();
-	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+	const URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
 	const supportedSchemeNames = [
 		"http",
 		"https",
@@ -12877,9 +13108,10 @@ var require_schemes = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 			wsComponent.secure = void 0;
 		}
 		if (wsComponent.resourceName) {
-			const [path, query] = wsComponent.resourceName.split("?");
+			const queryIndex = wsComponent.resourceName.indexOf("?");
+			const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
 			wsComponent.path = path && path !== "/" ? path : void 0;
-			wsComponent.query = query;
+			wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
 			wsComponent.resourceName = void 0;
 		}
 		wsComponent.fragment = void 0;
@@ -12892,7 +13124,7 @@ var require_schemes = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 			return urnComponent;
 		}
 		const matches = urnComponent.path.match(URN_REG);
-		if (matches) {
+		if (matches && matches[0] === urnComponent.path) {
 			const scheme = options.scheme || urnComponent.scheme || "urn";
 			urnComponent.nid = matches[1].toLowerCase();
 			urnComponent.nss = matches[2];
@@ -12986,8 +13218,19 @@ var require_schemes = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	};
 }));
 var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
-	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
 	const { SCHEMES, getSchemeHandler } = require_schemes();
+	const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+	const MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+	/**
+	* @param {string} scheme
+	* @returns {string}
+	*/
+	function decodeValidScheme(scheme) {
+		const decodedScheme = unescape(String(scheme));
+		if (!VALID_SCHEME.test(decodedScheme)) throw new TypeError(MALFORMED_SCHEME_ERROR);
+		return decodedScheme;
+	}
 	/**
 	* @template {import('./types/index').URIComponent|string} T
 	* @param {T} uri
@@ -13007,10 +13250,16 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	*/
 	function resolve(baseURI, relativeURI, options) {
 		const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-		const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-		const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-		if (baseMalformed || relativeMalformed) throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+		const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed, malformedPercentEncoding: baseMalformedPercentEncoding, malformedSchemeSpecific: baseMalformedSchemeSpecific, malformedHost: baseMalformedHost, malformedScheme: baseMalformedScheme } = parseWithStatus(baseURI, schemelessOptions);
+		const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed, malformedPercentEncoding: relativeMalformedPercentEncoding, malformedSchemeSpecific: relativeMalformedSchemeSpecific, malformedHost: relativeMalformedHost, malformedScheme: relativeMalformedScheme } = parseWithStatus(relativeURI, schemelessOptions);
+		if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
 		const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+		const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+		const resolvedHost = resolved.host;
+		const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+		canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+		const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+		if (resolved.error && !encodedASCIIHost) throw new Error(resolved.error);
 		schemelessOptions.skipEscape = true;
 		return serialize(resolved, schemelessOptions);
 	}
@@ -13076,7 +13325,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	function equal(uriA, uriB, options) {
 		const normalizedA = normalizeComparableURI(uriA, options);
 		const normalizedB = normalizeComparableURI(uriB, options);
-		return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+		return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
 	}
 	/**
 	* @param {Readonly<import('./types/index').URIComponent>} cmpts
@@ -13102,13 +13351,17 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 		};
 		const options = Object.assign({}, opts);
 		const uriTokens = [];
+		if (component.scheme) component.scheme = decodeValidScheme(component.scheme);
 		const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
 		if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
-		if (component.path !== void 0) if (!options.skipEscape) {
-			component.path = escapePreservingEscapes(component.path);
-			if (component.scheme !== void 0) component.path = component.path.split("%3A").join(":");
-		} else component.path = normalizePercentEncoding(component.path);
-		if (options.reference !== "suffix" && component.scheme) uriTokens.push(component.scheme, ":");
+		const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+		const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
+		if (component.path !== void 0) if (!options.skipEscape) component.path = serializePathEncoding(component.path, pathNoScheme);
+		else component.path = normalizePercentEncoding(component.path);
+		if (options.reference !== "suffix" && component.scheme) {
+			component.scheme = decodeValidScheme(component.scheme);
+			uriTokens.push(component.scheme, ":");
+		}
 		const authority = recomposeAuthority(component);
 		if (authority !== void 0) {
 			if (options.reference !== "suffix") uriTokens.push("//");
@@ -13118,11 +13371,12 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 		if (component.path !== void 0) {
 			let s = component.path;
 			if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = removeDotSegments(s);
+			if (pathNoScheme) s = serializePathEncoding(s, true);
 			if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
 			uriTokens.push(s);
 		}
-		if (component.query !== void 0) uriTokens.push("?", component.query);
-		if (component.fragment !== void 0) uriTokens.push("#", component.fragment);
+		if (component.query !== void 0) uriTokens.push("?", encodeQuery(component.query));
+		if (component.fragment !== void 0) uriTokens.push("#", encodeFragment(component.fragment));
 		return uriTokens.join("");
 	}
 	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
@@ -13138,9 +13392,61 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 		if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) return "URI port is malformed.";
 	}
 	/**
+	* Checks percent syntax without decoding the represented octets. RFC 3986
+	* percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
+	* though they are not independently valid UTF-8.
+	*
+	* @param {string|undefined} component
+	* @returns {boolean}
+	*/
+	function hasMalformedPercentEncoding(component) {
+		if (component === void 0) return false;
+		let percent = component.indexOf("%");
+		while (percent !== -1) {
+			if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) return true;
+			percent = component.indexOf("%", percent + 3);
+		}
+		return false;
+	}
+	/**
+	* Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
+	* An unterminated `[` is not a literal, so it must still be validated as a
+	* reg-name instead of being waved through as an IP.
+	*
+	* @param {string} host
+	* @returns {boolean}
+	*/
+	function isIPLiteral(host) {
+		return host[0] === "[" && host[host.length - 1] === "]";
+	}
+	/**
+	* @param {RegExpMatchArray} matches
+	* @returns {boolean}
+	*/
+	function hasMalformedComponentPercentEncoding(matches) {
+		const host = matches[4];
+		return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+	}
+	/**
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {import('./types/index').Options} options
+	* @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
+	* @param {boolean} isIP
+	* @returns {boolean} whether host conversion failed
+	*/
+	function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+		if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
+			parsed.host = new URL("http://" + parsed.host).hostname;
+		} catch (e) {
+			parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+			return true;
+		}
+		return false;
+	}
+	/**
 	* @param {string} uri
 	* @param {import('./types/index').Options} [opts]
-	* @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean }}
+	* @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
 	*/
 	function parseWithStatus(uri, opts) {
 		const options = Object.assign({}, opts);
@@ -13155,6 +13461,11 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 			fragment: void 0
 		};
 		let malformedAuthorityOrPort = false;
+		let malformedPercentEncoding = false;
+		let malformedSchemeSpecific = false;
+		let malformedHost = false;
+		let malformedIPLiteral = false;
+		let malformedScheme = false;
 		let isIP = false;
 		if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
 		else uri = "//" + uri;
@@ -13186,6 +13497,16 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 			parsed.path = matches[6] || "";
 			parsed.query = matches[7];
 			parsed.fragment = matches[8];
+			if (parsed.scheme !== void 0) {
+				const decodedScheme = unescape(parsed.scheme);
+				if (VALID_SCHEME.test(decodedScheme)) parsed.scheme = decodedScheme.toLowerCase();
+				else {
+					parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+					malformedScheme = true;
+				}
+			}
+			malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+			if (malformedPercentEncoding) parsed.error = parsed.error || "URI contains malformed percent-encoding.";
 			if (isNaN(parsed.port)) parsed.port = matches[5];
 			const parseError = getParseError(parsed, matches);
 			if (parseError !== void 0) {
@@ -13193,9 +13514,16 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 				malformedAuthorityOrPort = true;
 			}
 			if (parsed.host) if (isIPv4(parsed.host) === false) {
+				const bracketedIPLiteral = isIPLiteral(parsed.host);
+				const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
 				const ipv6result = normalizeIPv6(parsed.host);
-				parsed.host = ipv6result.host.toLowerCase();
-				isIP = ipv6result.isIPV6;
+				isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+				malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+				parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+				if (malformedIPLiteral) {
+					parsed.error = parsed.error || "URI host is malformed.";
+					malformedAuthorityOrPort = true;
+				}
 			} else isIP = true;
 			if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
 			else if (parsed.scheme === void 0) parsed.reference = "relative";
@@ -13203,30 +13531,30 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 			else parsed.reference = "uri";
 			if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
 			const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-			if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-				if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
-					parsed.host = new URL("http://" + parsed.host).hostname;
-				} catch (e) {
-					parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-				}
-			}
+			if (!malformedIPLiteral) malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
 			if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
 				if (uri.indexOf("%") !== -1) {
-					if (parsed.scheme !== void 0) parsed.scheme = unescape(parsed.scheme);
-					if (parsed.host !== void 0) parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+					if (parsed.host !== void 0 && !malformedIPLiteral) {
+						const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+						parsed.host = reescapeHostDelimiters(host, isIP);
+					}
 				}
 				if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
-				if (parsed.fragment) try {
-					parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-				} catch {
-					parsed.error = parsed.error || "URI malformed";
-				}
+				if (parsed.query) parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+				if (parsed.fragment) parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
+			}
+			if (schemeHandler && schemeHandler.parse) {
+				schemeHandler.parse(parsed, options);
+				if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) malformedSchemeSpecific = true;
 			}
-			if (schemeHandler && schemeHandler.parse) schemeHandler.parse(parsed, options);
 		} else parsed.error = parsed.error || "URI can not be parsed.";
 		return {
 			parsed,
-			malformedAuthorityOrPort
+			malformedAuthorityOrPort,
+			malformedPercentEncoding,
+			malformedSchemeSpecific,
+			malformedHost,
+			malformedScheme
 		};
 	}
 	/**
@@ -13248,13 +13576,17 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	/**
 	* @param {string} uri
 	* @param {import('./types/index').Options} [opts]
-	* @returns {{ normalized: string, malformedAuthorityOrPort: boolean }}
+	* @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
 	*/
 	function normalizeStringWithStatus(uri, opts) {
-		const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+		const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
 		return {
-			normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-			malformedAuthorityOrPort
+			normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+			malformedAuthorityOrPort,
+			malformedPercentEncoding,
+			malformedSchemeSpecific,
+			malformedHost,
+			malformedScheme
 		};
 	}
 	/**
@@ -13263,11 +13595,15 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 	* @returns {string|undefined}
 	*/
 	function normalizeComparableURI(uri, opts) {
-		if (typeof uri === "string") {
-			const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-			return malformedAuthorityOrPort ? void 0 : normalized;
+		if (typeof uri !== "string" && typeof uri !== "object") return;
+		let value;
+		try {
+			value = typeof uri === "string" ? uri : serialize(uri, opts);
+		} catch {
+			return;
 		}
-		if (typeof uri === "object") return serialize(uri, opts);
+		const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+		return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
 	}
 	const fastUri = {
 		SCHEMES,
@@ -16443,7 +16779,7 @@ var JsonSchemaWrapper = class {
 * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });
 * ```
 */
-function toStandardSchema$3(schema, options) {
+function toStandardSchema$4(schema, options) {
 	return new JsonSchemaWrapper(schema, options);
 }
 //#endregion
@@ -16519,7 +16855,7 @@ function convertToJsonSchema$1(zodSchema, options) {
 * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });
 * ```
 */
-function toStandardSchema$2(zodSchema) {
+function toStandardSchema$3(zodSchema) {
 	const wrapper = Object.create(zodSchema);
 	const existingStandard = zodSchema["~standard"];
 	const jsonSchemaConverter = {
@@ -16542,7 +16878,7 @@ function toStandardSchema$2(zodSchema) {
 	return wrapper;
 }
 //#endregion
-//#region ../schema-compat/dist/schema-Bv9OdW1f.js
+//#region ../schema-compat/dist/schema-D_ikovK6.js
 /**
 * Supported JSON Schema targets for z.toJSONSchema().
 * Works with both real Zod v4 and Zod 3.25's v4 compat layer.
@@ -16671,18 +17007,18 @@ function isZodV3(schema) {
 	}
 	return schema instanceof v3_default.ZodType;
 }
-function toStandardSchema(schema) {
+function toStandardSchema$2(schema) {
 	if (isZodV4(schema)) patchRecordSchemas(schema);
 	if (isStandardSchemaWithJSON$2(schema)) return schema;
 	if (isZodV4(schema)) return toStandardSchema$1(schema, {
 		unrepresentable: JSON_SCHEMA_LIBRARY_OPTIONS.unrepresentable,
 		override: JSON_SCHEMA_LIBRARY_OPTIONS.override
 	});
-	if (isZodV3(schema)) return toStandardSchema$2(schema);
-	if (isVercelSchema(schema)) return toStandardSchema$4(schema);
+	if (isZodV3(schema)) return toStandardSchema$3(schema);
+	if (isVercelSchema(schema)) return toStandardSchema$5(schema);
 	if (schema === null || typeof schema !== "object" && typeof schema !== "function") throw new Error(`Unsupported schema type: ${typeof schema}`);
 	if (typeof schema === "function") throw new Error(`Unsupported schema type: function (schema libraries should implement StandardSchemaWithJSON)`);
-	return toStandardSchema$3(schema);
+	return toStandardSchema$4(schema);
 }
 /**
 * Type guard to check if a value implements the StandardSchemaV1 interface.
@@ -22080,7 +22416,7 @@ var InternalMastraMCPClient = class extends _mastra_core_base.MastraBase {
 	convertOutputSchema(outputSchema) {
 		if (!outputSchema) return outputSchema;
 		return { "~standard": {
-			...toStandardSchema("jsonSchema" in outputSchema ? outputSchema.jsonSchema : outputSchema)["~standard"],
+			...toStandardSchema$2("jsonSchema" in outputSchema ? outputSchema.jsonSchema : outputSchema)["~standard"],
 			validate: (value) => ({ value })
 		} };
 	}
@@ -22201,7 +22537,7 @@ var InternalMastraMCPClient = class extends _mastra_core_base.MastraBase {
 				...annotations ? { annotations } : {}
 			} } : {};
 			const rawOutputSchema = tool.outputSchema ? "jsonSchema" in tool.outputSchema ? tool.outputSchema.jsonSchema : tool.outputSchema : void 0;
-			const outputValidator = rawOutputSchema ? toStandardSchema(rawOutputSchema) : void 0;
+			const outputValidator = rawOutputSchema ? toStandardSchema$2(rawOutputSchema) : void 0;
 			const mastraTool = (0, _mastra_core_tools.createTool)({
 				id: `${this.name}_${tool.name}`,
 				description: tool.description || "",
@@ -22948,38 +23284,30 @@ function isLoopbackHostname(hostname) {
 	return hostname === "localhost" || hostname === "[::1]" || hostname === "::1" || LOOPBACK_IPV4.test(hostname);
 }
 /**
-* MCPClient manages multiple MCP server connections and their tools in a Mastra application.
+* Manages Model Context Protocol (MCP) server connections and tool namespacing,
+* with access to tools, resources, prompts, and elicitation.
 *
-* This class handles connection lifecycle, tool namespacing, and provides access to tools,
-* resources, prompts, and elicitation across all configured servers.
+* Configure authentication when required by your servers.
 *
 * @example
+* `yourServerUrl` is a URL for a running MCP server's HTTP endpoint.
 * ```typescript
 * import { MCPClient } from '@mastra/mcp';
-* import { Agent } from '@mastra/core/agent';
 *
 * const mcp = new MCPClient({
 *   servers: {
-*     weather: {
-*       url: new URL('http://localhost:8080/sse'),
-*     },
-*     stockPrice: {
-*       command: 'npx',
-*       args: ['tsx', 'stock-price.ts'],
-*       env: { API_KEY: 'your-api-key' },
-*     },
+*     remote: { url: yourServerUrl },
 *   },
-*   timeout: 30000,
-* });
-*
-* const agent = new Agent({
-*   id: 'multi-tool-agent',
-*   name: 'Multi-tool Agent',
-*   instructions: 'You have access to multiple tools.',
-*   model: 'openai/gpt-4o',
-*   tools: await mcp.listTools(),
 * });
 * ```
+*
+* @see For documentation bundled with your installed package, locate
+* `@mastra/mcp/package.json` with your project's resolver or package-manager
+* tooling, then read `dist/docs/SKILL.md` from that package root and follow its
+* reference links. Use package-manager tools for virtual or archived packages.
+*
+* @see [MCP client documentation](https://mastra.ai/reference/tools/mcp-client)
+* if packaged docs are unavailable.
 */
 var MCPClient = class extends _mastra_core_base.MastraBase {
 	serverConfigs = {};
@@ -24386,7 +24714,7 @@ var streamSSE = (c, cb, onError) => {
 	return c.newResponse(stream.responseReadable);
 };
 //#endregion
-//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/hono-mcp-server-sse-transport/0.0.7/2a63beb8624fb1bf3c7a3ca090a15654580e3b90bf86b236de2fea1561bf2a49/node_modules/hono-mcp-server-sse-transport/build/sse.js
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/hono-mcp-server-sse-transport/0.0.7/64266f0b1652040acd07ff3bd56a63a27af87510caf8cd4ce871013cbd451c67/node_modules/hono-mcp-server-sse-transport/build/sse.js
 const MAXIMUM_MESSAGE_SIZE = 4 * 1024 * 1024;
 var SSETransport = class {
 	messageUrl;
@@ -24899,32 +25227,30 @@ const ACCEPTED_MODERN_ERA_HTTP_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"sessionIdGenerator"
 ]);
 /**
-* MCPServer exposes Mastra tools, agents, and workflows as a Model Context Protocol (MCP) server.
-*
-* This class allows any MCP client (like Cursor, Windsurf, or Claude Desktop) to connect and use your
-* Mastra capabilities. It supports both stdio (subprocess) and SSE (HTTP) MCP transports.
+* Exposes Mastra tools, agents, and workflows to Model Context Protocol (MCP) clients.
+* Supports stdio, SSE, and Streamable HTTP transports; start or mount a transport
+* to accept client connections.
 *
 * @example
+* `yourTool` is a tool you have already configured.
 * ```typescript
 * import { MCPServer } from '@mastra/mcp';
-* import { createTool } from '@mastra/core/tools';
-* import { z } from 'zod';
-*
-* const weatherTool = createTool({
-*   id: 'getWeather',
-*   description: 'Gets the current weather for a location.',
-*   inputSchema: z.object({ location: z.string() }),
-*   execute: async (inputData) => `Weather in ${inputData.location} is sunny.`,
-* });
 *
 * const server = new MCPServer({
-*   name: 'My Weather Server',
+*   id: 'my-server',
+*   name: 'My Server',
 *   version: '1.0.0',
-*   tools: { weatherTool },
+*   tools: { yourTool },
 * });
-*
-* await server.startStdio();
 * ```
+*
+* @see For documentation bundled with your installed package, locate
+* `@mastra/mcp/package.json` with your project's resolver or package-manager
+* tooling, then read `dist/docs/SKILL.md` from that package root and follow its
+* reference links. Use package-manager tools for virtual or archived packages.
+*
+* @see [MCP server documentation](https://mastra.ai/reference/tools/mcp-server)
+* if packaged docs are unavailable.
 */
 var MCPServer = class extends _mastra_core_mcp.MCPServerBase {
 	server;
@@ -27073,6 +27399,688 @@ var MCPServer = class extends _mastra_core_mcp.MCPServerBase {
 	}
 };
 //#endregion
+//#region src/server/mastra-api-operations.generated.ts
+const MASTRA_API_OPERATIONS = [
+	{
+		name: "agent_list",
+		description: "List available agents",
+		method: "GET",
+		path: "/agents",
+		destructive: false
+	},
+	{
+		name: "agent_get",
+		description: "Get agent details",
+		method: "GET",
+		path: "/agents/:agentId",
+		destructive: false
+	},
+	{
+		name: "agent_run",
+		description: "Run an agent with JSON input",
+		method: "POST",
+		path: "/agents/:agentId/generate",
+		destructive: true
+	},
+	{
+		name: "workflow_list",
+		description: "List available workflows",
+		method: "GET",
+		path: "/workflows",
+		destructive: false
+	},
+	{
+		name: "workflow_get",
+		description: "Get workflow details",
+		method: "GET",
+		path: "/workflows/:workflowId",
+		destructive: false
+	},
+	{
+		name: "workflow_run_start",
+		description: "Start a workflow run",
+		method: "POST",
+		path: "/workflows/:workflowId/start-async",
+		destructive: true
+	},
+	{
+		name: "workflow_run_list",
+		description: "List workflow runs",
+		method: "GET",
+		path: "/workflows/:workflowId/runs",
+		destructive: false
+	},
+	{
+		name: "workflow_run_get",
+		description: "Get workflow run details",
+		method: "GET",
+		path: "/workflows/:workflowId/runs/:runId",
+		destructive: false
+	},
+	{
+		name: "workflow_run_resume",
+		description: "Resume a suspended workflow run",
+		method: "POST",
+		path: "/workflows/:workflowId/resume-async",
+		destructive: true
+	},
+	{
+		name: "workflow_run_cancel",
+		description: "Cancel a workflow run",
+		method: "POST",
+		path: "/workflows/:workflowId/runs/:runId/cancel",
+		destructive: true
+	},
+	{
+		name: "tool_list",
+		description: "List available tools",
+		method: "GET",
+		path: "/tools",
+		destructive: false
+	},
+	{
+		name: "tool_get",
+		description: "Get tool details and input schema",
+		method: "GET",
+		path: "/tools/:toolId",
+		destructive: false
+	},
+	{
+		name: "tool_execute",
+		description: "Execute a tool with JSON input",
+		method: "POST",
+		path: "/tools/:toolId/execute",
+		destructive: true
+	},
+	{
+		name: "mcp_list",
+		description: "List MCP servers",
+		method: "GET",
+		path: "/mcp/v0/servers",
+		destructive: false
+	},
+	{
+		name: "mcp_get",
+		description: "Get MCP server details",
+		method: "GET",
+		path: "/mcp/v0/servers/:id",
+		destructive: false
+	},
+	{
+		name: "mcp_tool_list",
+		description: "List tools for an MCP server",
+		method: "GET",
+		path: "/mcp/:serverId/tools",
+		destructive: false
+	},
+	{
+		name: "mcp_tool_get",
+		description: "Get MCP tool details",
+		method: "GET",
+		path: "/mcp/:serverId/tools/:toolId",
+		destructive: false
+	},
+	{
+		name: "mcp_tool_execute",
+		description: "Execute an MCP tool with JSON input",
+		method: "POST",
+		path: "/mcp/:serverId/tools/:toolId/execute",
+		destructive: true
+	},
+	{
+		name: "thread_list",
+		description: "List memory threads",
+		method: "GET",
+		path: "/memory/threads",
+		destructive: false
+	},
+	{
+		name: "thread_get",
+		description: "Get thread details",
+		method: "GET",
+		path: "/memory/threads/:threadId",
+		destructive: false
+	},
+	{
+		name: "thread_create",
+		description: "Create a memory thread",
+		method: "POST",
+		path: "/memory/threads",
+		destructive: true
+	},
+	{
+		name: "thread_update",
+		description: "Update a memory thread",
+		method: "PATCH",
+		path: "/memory/threads/:threadId",
+		destructive: true
+	},
+	{
+		name: "thread_delete",
+		description: "Delete a memory thread",
+		method: "DELETE",
+		path: "/memory/threads/:threadId",
+		destructive: true
+	},
+	{
+		name: "thread_messages",
+		description: "List messages in a memory thread",
+		method: "GET",
+		path: "/memory/threads/:threadId/messages",
+		destructive: false
+	},
+	{
+		name: "memory_search",
+		description: "Search long-term memory",
+		method: "GET",
+		path: "/memory/search",
+		destructive: false
+	},
+	{
+		name: "memory_current_get",
+		description: "Get current working memory",
+		method: "GET",
+		path: "/memory/threads/:threadId/working-memory",
+		destructive: false
+	},
+	{
+		name: "memory_current_update",
+		description: "Update current working memory",
+		method: "POST",
+		path: "/memory/threads/:threadId/working-memory",
+		destructive: true
+	},
+	{
+		name: "memory_status",
+		description: "Get memory system status",
+		method: "GET",
+		path: "/memory/status",
+		destructive: false
+	},
+	{
+		name: "trace_list",
+		description: "List observability traces",
+		method: "GET",
+		path: "/observability/traces/light",
+		verbosePath: "/observability/traces",
+		destructive: false
+	},
+	{
+		name: "trace_get",
+		description: "Get trace details",
+		method: "GET",
+		path: "/observability/traces/:traceId/light",
+		verbosePath: "/observability/traces/:traceId",
+		destructive: false
+	},
+	{
+		name: "trace_span",
+		description: "Get a trace span",
+		method: "GET",
+		path: "/observability/traces/:traceId/spans/:spanId",
+		destructive: false
+	},
+	{
+		name: "log_list",
+		description: "List runtime logs",
+		method: "GET",
+		path: "/observability/logs",
+		destructive: false
+	},
+	{
+		name: "metric_aggregate",
+		description: "Get an aggregate metric value",
+		method: "POST",
+		path: "/observability/metrics/aggregate",
+		destructive: true
+	},
+	{
+		name: "metric_breakdown",
+		description: "Get metric values grouped by a label or field",
+		method: "POST",
+		path: "/observability/metrics/breakdown",
+		destructive: true
+	},
+	{
+		name: "metric_timeseries",
+		description: "Get metric values over time",
+		method: "POST",
+		path: "/observability/metrics/timeseries",
+		destructive: true
+	},
+	{
+		name: "metric_percentiles",
+		description: "Get metric percentile values over time",
+		method: "POST",
+		path: "/observability/metrics/percentiles",
+		destructive: true
+	},
+	{
+		name: "metric_names",
+		description: "List discovered metric names",
+		method: "GET",
+		path: "/observability/discovery/metric-names",
+		destructive: false
+	},
+	{
+		name: "metric_label_keys",
+		description: "List label keys for a metric",
+		method: "GET",
+		path: "/observability/discovery/metric-label-keys",
+		destructive: false
+	},
+	{
+		name: "metric_label_values",
+		description: "List label values for a metric label key",
+		method: "GET",
+		path: "/observability/discovery/metric-label-values",
+		destructive: false
+	},
+	{
+		name: "score_create",
+		description: "Create a score",
+		method: "POST",
+		path: "/observability/scores",
+		destructive: true
+	},
+	{
+		name: "score_list",
+		description: "List scores",
+		method: "GET",
+		path: "/observability/scores",
+		destructive: false
+	},
+	{
+		name: "score_get",
+		description: "Get score details",
+		method: "GET",
+		path: "/observability/scores/:scoreId",
+		destructive: false
+	},
+	{
+		name: "dataset_list",
+		description: "List datasets",
+		method: "GET",
+		path: "/datasets",
+		destructive: false
+	},
+	{
+		name: "dataset_get",
+		description: "Get dataset details",
+		method: "GET",
+		path: "/datasets/:datasetId",
+		destructive: false
+	},
+	{
+		name: "dataset_create",
+		description: "Create a dataset",
+		method: "POST",
+		path: "/datasets",
+		destructive: true
+	},
+	{
+		name: "dataset_items",
+		description: "List dataset items",
+		method: "GET",
+		path: "/datasets/:datasetId/items",
+		destructive: false
+	},
+	{
+		name: "experiment_list",
+		description: "List dataset experiments",
+		method: "GET",
+		path: "/datasets/:datasetId/experiments",
+		destructive: false
+	},
+	{
+		name: "experiment_get",
+		description: "Get experiment details",
+		method: "GET",
+		path: "/datasets/:datasetId/experiments/:experimentId",
+		destructive: false
+	},
+	{
+		name: "experiment_run",
+		description: "Run a dataset experiment",
+		method: "POST",
+		path: "/datasets/:datasetId/experiments",
+		destructive: true
+	},
+	{
+		name: "experiment_results",
+		description: "List experiment results",
+		method: "GET",
+		path: "/datasets/:datasetId/experiments/:experimentId/results",
+		destructive: false
+	},
+	{
+		name: "learning_entities",
+		description: "List entities with Trace Intelligence output",
+		method: "GET",
+		path: "/learning/entities",
+		destructive: false
+	},
+	{
+		name: "learning_snapshots",
+		description: "List analysis snapshots for an entity and ordered trace signals",
+		method: "GET",
+		path: "/learning/entities/:entityId/theme-snapshots",
+		destructive: false
+	},
+	{
+		name: "learning_flow",
+		description: "Get the cross-signal theme flow for one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/theme-flow",
+		destructive: false
+	},
+	{
+		name: "learning_paths",
+		description: "Get per-trace theme assignments for one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/theme-paths",
+		destructive: false
+	},
+	{
+		name: "learning_theme_list",
+		description: "List themes for one trace signal in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes",
+		destructive: false
+	},
+	{
+		name: "learning_theme_get",
+		description: "Get one theme in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes/:themeId",
+		destructive: false
+	},
+	{
+		name: "learning_theme_examples",
+		description: "List trace examples for one theme in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes/:themeId/examples",
+		destructive: false
+	},
+	{
+		name: "learning_theme_history",
+		description: "Get lifecycle history for one durable theme",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes/:themeId/history",
+		destructive: false
+	},
+	{
+		name: "learning_noise_get",
+		description: "Get the noise bucket for one trace signal in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/noise",
+		destructive: false
+	},
+	{
+		name: "learning_noise_examples",
+		description: "List trace examples for the noise bucket in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/noise/examples",
+		destructive: false
+	}
+];
+//#endregion
+//#region src/server/mastra-api-mcp-server.ts
+var MastraApiRequester = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async getSchemaManifest() {
+		const value = await this.request({
+			method: "GET",
+			path: "/system/api-schema",
+			pathParamSchema: void 0,
+			queryParamSchema: void 0,
+			bodySchema: void 0
+		}, {});
+		if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.routes)) throw new Error("The Mastra server returned an invalid API schema manifest. Confirm that the target server supports GET /api/system/api-schema.");
+		const routes = value.routes.filter(isApiSchemaRoute);
+		if (routes.length !== value.routes.length) throw new Error("The Mastra server API schema manifest contains an invalid route definition.");
+		return routes;
+	}
+	async request(route, input, authInfo, requestSignal) {
+		const pathParams = schemaPropertyNames(route.pathParamSchema);
+		const queryParams = new Set(schemaPropertyNames(route.queryParamSchema));
+		const bodyParams = new Set(schemaPropertyNames(route.bodySchema));
+		const remainingInput = { ...input };
+		let path = route.path;
+		for (const name of pathParams) {
+			path = path.replace(`:${name}`, encodeURIComponent(remainingInput[name]));
+			delete remainingInput[name];
+		}
+		const url = new URL(joinUrl(this.options.baseUrl, this.options.apiPrefix, path));
+		const body = {};
+		for (const [name, value] of Object.entries(remainingInput)) {
+			if (value === void 0) continue;
+			if (route.method === "GET" || queryParams.has(name) && !bodyParams.has(name)) {
+				if (value === null) continue;
+				url.searchParams.set(name, typeof value === "object" ? JSON.stringify(value) : String(value));
+			} else body[name] = value;
+		}
+		const headers = new Headers(this.options.headers);
+		headers.set("accept", "application/json");
+		const callerToken = getAuthToken(authInfo);
+		if (callerToken) headers.set("authorization", `Bearer ${callerToken}`);
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("request timed out")), this.options.timeoutMs);
+		const abortRequest = () => controller.abort(requestSignal?.reason);
+		if (requestSignal?.aborted) abortRequest();
+		else requestSignal?.addEventListener("abort", abortRequest, { once: true });
+		try {
+			const hasBody = route.method !== "GET" && route.bodySchema !== void 0;
+			if (hasBody) headers.set("content-type", "application/json");
+			const response = await this.options.fetch(url, {
+				method: route.method,
+				headers,
+				signal: controller.signal,
+				...hasBody ? { body: JSON.stringify(body) } : {}
+			});
+			const responseBody = await readResponseBody(response);
+			if (!response.ok) {
+				const detail = getErrorDetail(responseBody);
+				throw new Error(`Mastra API request ${route.method} ${route.path} failed with status ${response.status}${detail ? `: ${detail}` : "."}`);
+			}
+			return responseBody;
+		} catch (error) {
+			if (controller.signal.aborted) {
+				if (requestSignal?.aborted) throw new Error(`Mastra API request ${route.method} ${route.path} was canceled.`, { cause: error });
+				throw new Error(`Mastra API request ${route.method} ${route.path} timed out after ${this.options.timeoutMs}ms.`, { cause: error });
+			}
+			if (error instanceof Error && error.message.startsWith("Mastra API request ")) throw error;
+			throw new Error(`Could not reach the Mastra server at ${this.options.baseUrl}. Check the server URL and network access.`, { cause: error });
+		} finally {
+			clearTimeout(timeout);
+			requestSignal?.removeEventListener("abort", abortRequest);
+		}
+	}
+};
+/**
+* An MCP server that exposes the Mastra API CLI operations from a remote Mastra server.
+*
+* The factory reads the target server's schema manifest, registers the CLI operations
+* supported by that server, and uses the route schemas as MCP tool input schemas.
+*/
+var MastraApiMCPServer = class MastraApiMCPServer extends MCPServer {
+	constructor(options, tools) {
+		super({
+			id: options.id ?? "mastra-api",
+			name: options.name ?? "Mastra Server",
+			version: options.version ?? "1.0.0",
+			description: "Inspect and operate a Mastra server.",
+			instructions: "Inspect resources before using them. Pass tool input inside the data field for tool_execute and mcp_tool_execute. Ask for confirmation before calling a tool marked as destructive.",
+			protocolVersion: "2026-07-28",
+			tools
+		});
+	}
+	/** Creates a stateless MCP server for the target Mastra server. */
+	static async create(options) {
+		const requester = new MastraApiRequester(normalizeOptions(options));
+		const tools = createApiTools(await requester.getSchemaManifest(), requester);
+		if (Object.keys(tools).length === 0) throw new Error("The target Mastra server does not support any of the MCP server operations.");
+		return new MastraApiMCPServer(options, tools);
+	}
+};
+function createApiTools(routes, requester) {
+	const tools = {};
+	for (const operation of MASTRA_API_OPERATIONS) {
+		const primaryRoute = routes.find((candidate) => candidate.method === operation.method && candidate.path === operation.path);
+		const verboseRoute = "verbosePath" in operation ? routes.find((candidate) => candidate.method === operation.method && candidate.path === operation.verbosePath) : void 0;
+		const route = primaryRoute ?? verboseRoute;
+		if (!route) continue;
+		const readOnly = operation.method === "GET";
+		tools[operation.name] = (0, _mastra_core_tools.createTool)({
+			id: operation.name,
+			description: operation.description,
+			inputSchema: (0, _mastra_core_schema.toStandardSchema)(mergeInputSchemas(route, primaryRoute !== void 0 && verboseRoute !== void 0)),
+			mcp: { annotations: {
+				title: operation.description,
+				readOnlyHint: readOnly,
+				destructiveHint: operation.destructive,
+				idempotentHint: readOnly || operation.method === "DELETE",
+				openWorldHint: true
+			} },
+			execute: async (input, context) => {
+				let requestInput = input;
+				let selectedRoute = route;
+				if (primaryRoute && verboseRoute) {
+					const { verbose, ...inputWithoutVerbose } = input;
+					requestInput = inputWithoutVerbose;
+					if (verbose === true) selectedRoute = verboseRoute;
+				}
+				return requester.request(selectedRoute, requestInput, context.mcp?.extra.authInfo ?? getRequestAuthInfo(context.requestContext), context.abortSignal ?? context.mcp?.extra.signal);
+			}
+		});
+	}
+	return tools;
+}
+function normalizeOptions(options) {
+	let url;
+	try {
+		url = new URL(options.url);
+	} catch (error) {
+		throw new Error("The Mastra server URL must be a valid absolute URL.", { cause: error });
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("The Mastra server URL must use HTTP or HTTPS.");
+	if (url.username || url.password) throw new Error("The Mastra server URL cannot contain credentials. Use the headers option for authentication.");
+	if (url.search || url.hash) throw new Error("The Mastra server URL cannot contain a query string or fragment.");
+	const apiPrefix = normalizeApiPrefix(options.apiPrefix ?? "/api");
+	const timeoutMs = options.timeoutMs ?? 12e4;
+	if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error("The request timeout must be a positive integer in milliseconds.");
+	return {
+		baseUrl: url.toString().replace(/\/$/, ""),
+		apiPrefix,
+		headers: { ...options.headers },
+		timeoutMs,
+		fetch: options.fetch ?? globalThis.fetch
+	};
+}
+function normalizeApiPrefix(value) {
+	if (value.includes("..") || value.includes("?") || value.includes("#")) throw new Error("The Mastra API prefix cannot contain \"..\", a query string, or a fragment.");
+	let start = 0;
+	let end = value.length;
+	while (start < end && value[start] === "/") start++;
+	while (end > start && value[end - 1] === "/") end--;
+	return start === end ? "" : `/${value.slice(start, end)}`;
+}
+function joinUrl(baseUrl, apiPrefix, path) {
+	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+	if (!apiPrefix || baseUrl.endsWith(apiPrefix)) return `${baseUrl}${normalizedPath}`;
+	return `${baseUrl}${apiPrefix}${normalizedPath}`;
+}
+function mergeInputSchemas(route, supportsVerbose = false) {
+	const definitions = {};
+	const schemas = [
+		"pathParamSchema",
+		"queryParamSchema",
+		"bodySchema"
+	].flatMap((key) => {
+		const source = route[key];
+		if (!isRecord(source)) return [];
+		const schema = relocateSchemaReferences(source, `#/definitions/${key}`);
+		definitions[key] = schema;
+		return [schema];
+	});
+	const properties = {};
+	const pathParams = new Set(schemaPropertyNames(route.pathParamSchema));
+	const required = new Set(pathParams);
+	let allowsAdditionalProperties = false;
+	for (const schema of schemas) {
+		if (isRecord(schema.properties)) for (const [name, property] of Object.entries(schema.properties)) properties[name] = pathParams.has(name) && Object.hasOwn(properties, name) ? { allOf: [properties[name], property] } : property;
+		if (Array.isArray(schema.required)) {
+			for (const name of schema.required) if (typeof name === "string") required.add(name);
+		}
+		if (schema.additionalProperties === true || isRecord(schema.additionalProperties)) allowsAdditionalProperties = true;
+	}
+	if (supportsVerbose) properties.verbose = {
+		type: "boolean",
+		description: "Return the full response instead of the lightweight response.",
+		default: false
+	};
+	for (const name of pathParams) properties[name] = {
+		type: "string",
+		minLength: 1,
+		allOf: [properties[name]]
+	};
+	return {
+		type: "object",
+		properties,
+		required: [...required],
+		additionalProperties: allowsAdditionalProperties,
+		definitions
+	};
+}
+function relocateSchemaReferences(value, root) {
+	if (Array.isArray(value)) return value.map((item) => relocateSchemaReferences(item, root));
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key === "$ref" && typeof child === "string" && (child === "#" || child.startsWith("#/")) ? `${root}${child.slice(1)}` : relocateSchemaReferences(child, root)]));
+}
+function schemaPropertyNames(schema) {
+	return isRecord(schema?.properties) ? Object.keys(schema.properties) : [];
+}
+function isApiSchemaRoute(value) {
+	if (!isRecord(value) || typeof value.method !== "string" || typeof value.path !== "string") return false;
+	return [
+		"pathParamSchema",
+		"queryParamSchema",
+		"bodySchema"
+	].every((key) => value[key] === void 0 || isRecord(value[key]));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getAuthToken(authInfo) {
+	if (!isRecord(authInfo)) return void 0;
+	return typeof authInfo.token === "string" && authInfo.token.length > 0 ? authInfo.token : void 0;
+}
+function getRequestAuthInfo(requestContext) {
+	const authInfo = requestContext?.get("authInfo");
+	if (authInfo !== void 0) return authInfo;
+	const token = requestContext?.get(_mastra_core_request_context.MASTRA_AUTH_TOKEN_KEY);
+	return typeof token === "string" && token.length > 0 ? { token } : void 0;
+}
+async function readResponseBody(response) {
+	const text = await response.text();
+	if (!text) return null;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function getErrorDetail(body) {
+	if (typeof body === "string") return body.slice(0, 500);
+	if (!isRecord(body)) return void 0;
+	const error = isRecord(body.error) ? body.error : body;
+	if (typeof error.message === "string") return error.message.slice(0, 500);
+	return JSON.stringify(body).slice(0, 500);
+}
+//#endregion
 //#region src/server/oauth-middleware.ts
 /**
 * Creates an OAuth middleware function for protecting MCP server endpoints.
@@ -27327,6 +28335,7 @@ exports.MCPOAuthClientProvider = MCPOAuthClientProvider;
 exports.MCPServer = MCPServer;
 exports.MCP_CALL_TOOL_CONTENT = MCP_CALL_TOOL_CONTENT;
 exports.MCP_CALL_TOOL_META = MCP_CALL_TOOL_META;
+exports.MastraApiMCPServer = MastraApiMCPServer;
 Object.defineProperty(exports, "UnauthorizedError", {
 	enumerable: true,
 	get: function() {