@mastra/mcp 1.17.1 → 1.17.2

package/dist/index.js

@@ -17311,7 +17311,7 @@ var _AISDKError = class _AISDKError extends Error {
 };
 _a$1 = symbol$1;
 var AISDKError = _AISDKError;
-function getErrorMessage(error) {
+function getErrorMessage$1(error) {
 	if (error == null) return "unknown error";
 	if (typeof error === "string") return error;
 	if (error instanceof Error) return error.message;
@@ -17345,7 +17345,7 @@ var JSONParseError = class extends AISDKError {
 		super({
 			name: name6$1,
 			message: `JSON parsing failed: Text: ${text}.
-Error message: ${getErrorMessage(cause)}`,
+Error message: ${getErrorMessage$1(cause)}`,
 			cause
 		});
 		this[_a7$1] = true;
@@ -17365,7 +17365,7 @@ var _TypeValidationError = class _TypeValidationError extends AISDKError {
 		super({
 			name: name12$1,
 			message: `Type validation failed: Value: ${JSON.stringify(value)}.
-Error message: ${getErrorMessage(cause)}`,
+Error message: ${getErrorMessage$1(cause)}`,
 			cause
 		});
 		this[_a13$1] = true;
@@ -20977,6 +20977,72 @@ function isReconnectableMCPError(error) {
 	const errorMessage = error.message.toLowerCase();
 	return errorMessage.includes("no valid session") || errorMessage.includes("session") || errorMessage.includes("server not initialized") || errorMessage.includes("not connected") || errorMessage.includes("http 400") || errorMessage.includes("http 401") || errorMessage.includes("http 403") || errorMessage.includes("http 404") || errorMessage.includes("econnrefused") || errorMessage.includes("fetch failed") || errorMessage.includes("connection refused") || errorMessage.includes("connection closed") || errorMessage.includes("sse stream disconnected") || errorMessage.includes("typeerror: terminated");
 }
+const MAX_DISCOVERY_ERROR_CAUSE_DEPTH = 8;
+function isHttpStatus(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599;
+}
+function asErrorRecord(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function getErrorProperty(record, property) {
+	if (!record) return void 0;
+	try {
+		return record[property];
+	} catch {
+		return;
+	}
+}
+function getErrorMessage(error) {
+	const message = getErrorProperty(asErrorRecord(error), "message");
+	if (typeof message === "string") return message;
+	try {
+		return String(error);
+	} catch {
+		return "Unknown error";
+	}
+}
+/**
+* Preserve machine-readable transport metadata before aggregate discovery turns
+* a thrown error into its legacy per-server string.
+*
+* MCP SDK 2 keeps an HTTP response status on `SdkHttpError.status` while
+* `code` is a string SDK code. Older transports and wrappers have also used
+* `statusCode`; only explicit status fields are treated as HTTP metadata so a
+* numeric SDK or application `code` is not mislabeled. The walk is bounded and
+* cycle-safe because application errors may wrap arbitrary third-party causes.
+*/
+function getMCPDiscoveryErrorDetails(error) {
+	let message = getErrorMessage(error);
+	let httpStatus;
+	let code;
+	let current = error;
+	const seen = /* @__PURE__ */ new Set();
+	for (let depth = 0; depth < MAX_DISCOVERY_ERROR_CAUSE_DEPTH && current !== void 0 && current !== null && !seen.has(current); depth++) {
+		seen.add(current);
+		const record = asErrorRecord(current);
+		if (!record) break;
+		const data = asErrorRecord(getErrorProperty(record, "data"));
+		if (httpStatus === void 0) {
+			for (const candidate of [
+				getErrorProperty(record, "status"),
+				getErrorProperty(record, "statusCode"),
+				getErrorProperty(data, "status"),
+				getErrorProperty(data, "statusCode")
+			]) if (isHttpStatus(candidate)) {
+				httpStatus = candidate;
+				break;
+			}
+		}
+		for (const candidate of [getErrorProperty(record, "code"), getErrorProperty(data, "code")]) if (typeof candidate === "string" || typeof candidate === "number") code = candidate;
+		current = getErrorProperty(record, "cause");
+	}
+	if (httpStatus !== void 0 && !message.includes(`(HTTP ${httpStatus})`)) message += ` (HTTP ${httpStatus})`;
+	return {
+		message,
+		...httpStatus !== void 0 ? { httpStatus } : {},
+		...code !== void 0 ? { code } : {}
+	};
+}
 //#endregion
 //#region src/client/url-policy.ts
 /**
@@ -21210,20 +21276,53 @@ function extractModelTextFromToolContent(content) {
 /**
 * Non-enumerable metadata attached to structured tool execute results so
 * `toModelOutput` can read MCP `content` without changing the execute return shape.
+*
+* When a tool has an `outputSchema` and the server returns `structuredContent`,
+* `execute()` returns that structured value directly. The rest of the
+* CallToolResult envelope is preserved on non-enumerable symbols:
+* - {@link MCP_CALL_TOOL_CONTENT} holds the MCP `content` blocks (model-facing text).
+* - {@link MCP_CALL_TOOL_META} holds the result-level `_meta` (e.g. `ui.resourceUri`
+*   used by MCP Apps hosts), with `ui.serverId` stamped by the client.
+*
+* Read them with {@link getMcpCallToolContent} and {@link getMcpCallToolMeta}.
+* Note: scalar or `null` structured results cannot carry properties, so these
+* channels are only available when `structuredContent` is an object or array.
 */
 const MCP_CALL_TOOL_CONTENT = Symbol.for("mastra.mcp.callToolContent");
-function attachMcpCallToolContent(structuredContent, content) {
-	if (structuredContent !== null && typeof structuredContent === "object") Object.defineProperty(structuredContent, MCP_CALL_TOOL_CONTENT, {
-		value: content,
-		enumerable: false,
-		configurable: true
-	});
+/** Non-enumerable result-level `_meta` attached to structured tool execute results. */
+const MCP_CALL_TOOL_META = Symbol.for("mastra.mcp.callToolMeta");
+function attachMcpCallToolContent(structuredContent, content, _meta) {
+	if (structuredContent !== null && typeof structuredContent === "object") {
+		Object.defineProperty(structuredContent, MCP_CALL_TOOL_CONTENT, {
+			value: content,
+			enumerable: false,
+			configurable: true
+		});
+		if (_meta !== void 0) Object.defineProperty(structuredContent, MCP_CALL_TOOL_META, {
+			value: _meta,
+			enumerable: false,
+			configurable: true
+		});
+	}
 	return structuredContent;
 }
+/**
+* Read the MCP `content` blocks preserved on a structured tool execute result.
+* Returns `undefined` for scalar results or results without a hidden content channel.
+*/
 function getMcpCallToolContent(output) {
 	if (output === null || typeof output !== "object") return void 0;
 	return output[MCP_CALL_TOOL_CONTENT];
 }
+/**
+* Read the result-level `_meta` preserved on a structured tool execute result
+* (e.g. `_meta.ui.resourceUri` for MCP Apps detection). Returns `undefined` for
+* scalar results or results whose CallToolResult had no `_meta`.
+*/
+function getMcpCallToolMeta(output) {
+	if (output === null || typeof output !== "object") return void 0;
+	return output[MCP_CALL_TOOL_META];
+}
 function createStructuredToolToModelOutput() {
 	return (output) => {
 		const modelText = extractModelTextFromToolContent(getMcpCallToolContent(output));
@@ -22130,7 +22229,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 								});
 							}
 							this.log("debug", `Tool executed successfully: ${tool.name}`);
-							if (res.structuredContent !== void 0) return attachMcpCallToolContent(res.structuredContent, res.content);
+							if (res.structuredContent !== void 0) return attachMcpCallToolContent(res.structuredContent, res.content, res._meta ? this.stampServerIdInMeta(res._meta) : void 0);
 							return res;
 						};
 						const failedTransport = this.transport;
@@ -23051,15 +23150,12 @@ onRequest: async (serverName, handler) => {
 			* console.log(resources.weatherServer); // Array of resources
 			* ```
 			*/
-			list: async () => {
-				const allResources = {};
-				const settled = await this.discoverAcrossServers(async (serverName) => (await this.getConnectedClientForServer(serverName)).resources.list(), {
-					errorId: "MCP_CLIENT_LIST_RESOURCES_FAILED",
-					logMessage: "Failed to list resources from server:"
-				});
-				for (const { serverName, value, error } of settled) if (error === void 0) allResources[serverName] = value;
-				return allResources;
-			},
+			list: async () => (await this.listResourcesWithErrors()).resources,
+			/**
+			* Lists resources while preserving per-server discovery failures.
+			* The existing `list()` method remains the success-only convenience API.
+			*/
+			listWithErrors: (options) => this.listResourcesWithErrors(options),
 			/**
 			* Lists all available resource templates from all configured servers.
 			*
@@ -23074,15 +23170,12 @@ onRequest: async (serverName, handler) => {
 			* console.log(templates.weatherServer); // Array of resource templates
 			* ```
 			*/
-			templates: async () => {
-				const allTemplates = {};
-				const settled = await this.discoverAcrossServers(async (serverName) => (await this.getConnectedClientForServer(serverName)).resources.templates(), {
-					errorId: "MCP_CLIENT_LIST_RESOURCE_TEMPLATES_FAILED",
-					logMessage: "Failed to list resource templates from server:"
-				});
-				for (const { serverName, value, error } of settled) if (error === void 0) allTemplates[serverName] = value;
-				return allTemplates;
-			},
+			templates: async () => (await this.listResourceTemplatesWithErrors()).templates,
+			/**
+			* Lists resource templates while preserving per-server discovery failures.
+			* The existing `templates()` method remains the success-only convenience API.
+			*/
+			templatesWithErrors: (options) => this.listResourceTemplatesWithErrors(options),
 			/**
 			* Reads the content of a specific resource from a server.
 			*
@@ -23265,15 +23358,12 @@ onRequest: async (serverName, handler) => {
 			* console.log(prompts.weatherServer); // Array of prompts
 			* ```
 			*/
-			list: async () => {
-				const allPrompts = {};
-				const settled = await this.discoverAcrossServers(async (serverName) => (await this.getConnectedClientForServer(serverName)).prompts.list(), {
-					errorId: "MCP_CLIENT_LIST_PROMPTS_FAILED",
-					logMessage: "Failed to list prompts from server:"
-				});
-				for (const { serverName, value, error } of settled) if (error === void 0) allPrompts[serverName] = value;
-				return allPrompts;
-			},
+			list: async () => (await this.listPromptsWithErrors()).prompts,
+			/**
+			* Lists prompts while preserving per-server discovery failures.
+			* The existing `list()` method remains the success-only convenience API.
+			*/
+			listWithErrors: (options) => this.listPromptsWithErrors(options),
 			/**
 			* Retrieves a specific prompt with its messages from a server.
 			*
@@ -23615,14 +23705,14 @@ onListChanged: async (serverName, handler) => {
 	* Like listTools(), but also returns errors for servers that failed to connect
 	* or list tools. This allows callers to report specific failure reasons per server.
 	*
-	* @returns Object with `tools` (successful tools) and `errors` (failed servers with error messages).
+	* @returns Object with successful `tools`, legacy string `errors`, and structured `errorDetails`.
 	* Transient connection failures are retried once after reconnecting the affected server.
 	*
 	* @example
 	* ```typescript
-	* const { tools, errors } = await mcp.listToolsWithErrors();
+	* const { tools, errors, errorDetails } = await mcp.listToolsWithErrors();
 	* for (const [name, err] of Object.entries(errors)) {
-	*   console.error(`Server ${name} failed: ${err}`);
+	*   console.error(`Server ${name} failed: ${err}`, errorDetails[name]);
 	* }
 	* ```
 	*/
@@ -23630,6 +23720,7 @@ onListChanged: async (serverName, handler) => {
 		this.addToInstanceCache();
 		const connectedTools = {};
 		const errors = {};
+		const errorDetails = {};
 		const durations = {};
 		const settled = await this.discoverAcrossServers((serverName) => this.getToolsForServer(serverName), {
 			errorId: "MCP_CLIENT_GET_TOOLS_FAILED",
@@ -23638,14 +23729,16 @@ onListChanged: async (serverName, handler) => {
 		for (const { serverName, value, error, duration } of settled) {
 			durations[serverName] = duration;
 			if (error !== void 0) {
-				errors[serverName] = error;
+				errors[serverName] = error.message;
+				errorDetails[serverName] = error;
 				continue;
 			}
 			for (const [toolName, toolConfig] of Object.entries(value)) connectedTools[`${serverName}_${toolName}`] = toolConfig;
 		}
 		const result = {
 			tools: connectedTools,
-			errors
+			errors,
+			errorDetails
 		};
 		return options ? {
 			...result,
@@ -23684,14 +23777,14 @@ onListChanged: async (serverName, handler) => {
 	* Like listToolsets(), but also returns errors for servers that failed to connect
 	* or list tools. This allows callers to report specific failure reasons per server.
 	*
-	* @returns Object with `toolsets` (successful servers) and `errors` (failed servers with error messages).
+	* @returns Object with successful `toolsets`, legacy string `errors`, and structured `errorDetails`.
 	* Transient connection failures are retried once after reconnecting the affected server.
 	*
 	* @example
 	* ```typescript
-	* const { toolsets, errors } = await mcp.listToolsetsWithErrors();
+	* const { toolsets, errors, errorDetails } = await mcp.listToolsetsWithErrors();
 	* for (const [name, err] of Object.entries(errors)) {
-	*   console.error(`Server ${name} failed: ${err}`);
+	*   console.error(`Server ${name} failed: ${err}`, errorDetails[name]);
 	* }
 	* ```
 	*/
@@ -23699,6 +23792,7 @@ onListChanged: async (serverName, handler) => {
 		this.addToInstanceCache();
 		const connectedToolsets = {};
 		const errors = {};
+		const errorDetails = {};
 		const durations = {};
 		const settled = await this.discoverAcrossServers((serverName) => this.getToolsForServer(serverName), {
 			errorId: "MCP_CLIENT_GET_TOOLSETS_FAILED",
@@ -23707,14 +23801,16 @@ onListChanged: async (serverName, handler) => {
 		for (const { serverName, value, error, duration } of settled) {
 			durations[serverName] = duration;
 			if (error !== void 0) {
-				errors[serverName] = error;
+				errors[serverName] = error.message;
+				errorDetails[serverName] = error;
 				continue;
 			}
 			connectedToolsets[serverName] = value;
 		}
 		const result = {
 			toolsets: connectedToolsets,
-			errors
+			errors,
+			errorDetails
 		};
 		return options ? {
 			...result,
@@ -23752,11 +23848,14 @@ onListChanged: async (serverName, handler) => {
 	*
 	* Useful when caching a catalog, since it lets you avoid persisting a partial manifest that
 	* silently omits a server which happened to be down at discovery time.
+	* `errors` remains a string map for compatibility; `errorDetails` preserves
+	* machine-readable transport status and error codes when available.
 	*/
 	async listToolDefinitionsWithErrors(options) {
 		this.addToInstanceCache();
 		const definitions = {};
 		const errors = {};
+		const errorDetails = {};
 		const durations = {};
 		const settled = await this.discoverAcrossServers(async (serverName) => {
 			return (await this.getConnectedClientForServer(serverName)).toolDefinitions();
@@ -23767,14 +23866,16 @@ onListChanged: async (serverName, handler) => {
 		for (const { serverName, value, error, duration } of settled) {
 			durations[serverName] = duration;
 			if (error !== void 0) {
-				errors[serverName] = error;
+				errors[serverName] = error.message;
+				errorDetails[serverName] = error;
 				continue;
 			}
 			definitions[serverName] = value;
 		}
 		const result = {
 			definitions,
-			errors
+			errors,
+			errorDetails
 		};
 		return options ? {
 			...result,
@@ -23831,6 +23932,59 @@ onListChanged: async (serverName, handler) => {
 		}
 		return tools;
 	}
+	async listResourcesWithErrors(options) {
+		const { values, ...diagnostics } = await this.discoverValuesWithErrors(async (serverName) => (await this.getConnectedClientForServer(serverName)).resources.list(), {
+			errorId: "MCP_CLIENT_LIST_RESOURCES_FAILED",
+			logMessage: "Failed to list resources from server:"
+		}, options);
+		return {
+			resources: values,
+			...diagnostics
+		};
+	}
+	async listResourceTemplatesWithErrors(options) {
+		const { values, ...diagnostics } = await this.discoverValuesWithErrors(async (serverName) => (await this.getConnectedClientForServer(serverName)).resources.templates(), {
+			errorId: "MCP_CLIENT_LIST_RESOURCE_TEMPLATES_FAILED",
+			logMessage: "Failed to list resource templates from server:"
+		}, options);
+		return {
+			templates: values,
+			...diagnostics
+		};
+	}
+	async listPromptsWithErrors(options) {
+		const { values, ...diagnostics } = await this.discoverValuesWithErrors(async (serverName) => (await this.getConnectedClientForServer(serverName)).prompts.list(), {
+			errorId: "MCP_CLIENT_LIST_PROMPTS_FAILED",
+			logMessage: "Failed to list prompts from server:"
+		}, options);
+		return {
+			prompts: values,
+			...diagnostics
+		};
+	}
+	async discoverValuesWithErrors(operation, onError, options) {
+		const values = {};
+		const errors = {};
+		const errorDetails = {};
+		const durations = {};
+		const settled = await this.discoverAcrossServers(operation, onError, options);
+		for (const { serverName, value, error, duration } of settled) {
+			durations[serverName] = duration;
+			if (error !== void 0) {
+				errors[serverName] = error.message;
+				errorDetails[serverName] = error;
+			} else values[serverName] = value;
+		}
+		const result = {
+			values,
+			errors,
+			errorDetails
+		};
+		return options ? {
+			...result,
+			durations
+		} : result;
+	}
 	/**
 	* Runs a per-server discovery `operation` against every configured server
 	* concurrently, isolating and logging per-server failures. Results are
@@ -23860,18 +24014,31 @@ onListChanged: async (serverName, handler) => {
 					duration: performance.now() - startedAt
 				};
 			} catch (error) {
-				const mastraError = new MastraError({
-					id: onError.errorId,
-					domain: ErrorDomain.MCP,
-					category: ErrorCategory.THIRD_PARTY,
-					details: { serverName }
-				}, error);
-				this.logger.trackException(mastraError);
-				this.logger.error(onError.logMessage, { error: mastraError.toString() });
+				const discoveryError = getMCPDiscoveryErrorDetails(error);
+				try {
+					const mastraError = new MastraError({
+						id: onError.errorId,
+						domain: ErrorDomain.MCP,
+						category: ErrorCategory.THIRD_PARTY,
+						details: { serverName }
+					}, error);
+					this.logger.trackException(mastraError);
+					this.logger.error(onError.logMessage, { error: mastraError.toString() });
+				} catch {
+					const fallbackError = new MastraError({
+						id: onError.errorId,
+						domain: ErrorDomain.MCP,
+						category: ErrorCategory.THIRD_PARTY,
+						text: discoveryError.message,
+						details: { serverName }
+					});
+					this.logger.trackException(fallbackError);
+					this.logger.error(onError.logMessage, { error: fallbackError.toString() });
+				}
 				return {
 					serverName,
 					value: void 0,
-					error: error instanceof Error ? error.message : String(error),
+					error: discoveryError,
 					duration: performance.now() - startedAt
 				};
 			} finally {
@@ -24440,7 +24607,6 @@ async function broadcastNotification({ servers, send, logger, errorId, errorText
 var ServerPromptActions = class {
 	getLogger;
 	getSdkServers;
-	clearDefinedPrompts;
 	getModernEraNotifier;
 	/**
 	* @internal
@@ -24448,14 +24614,13 @@ var ServerPromptActions = class {
 	constructor(dependencies) {
 		this.getLogger = dependencies.getLogger;
 		this.getSdkServers = dependencies.getSdkServers;
-		this.clearDefinedPrompts = dependencies.clearDefinedPrompts;
 		this.getModernEraNotifier = dependencies.getModernEraNotifier;
 	}
 	/**
 	* Notifies clients that the overall list of available prompts has changed.
 	*
-	* This clears the internal prompt cache and sends a `notifications/prompts/list_changed`
-	* message to all clients, prompting them to re-fetch the prompt list.
+	* This sends a `notifications/prompts/list_changed` message to all clients,
+	* prompting them to re-fetch the prompt list.
 	*
 	* @throws {MastraError} If sending the notification fails on all server instances
 	*
@@ -24466,8 +24631,7 @@ var ServerPromptActions = class {
 	* ```
 	*/
 	async notifyListChanged() {
-		this.getLogger().info("Prompt list change externally notified. Clearing definedPrompts and sending notification.");
-		this.clearDefinedPrompts();
+		this.getLogger().info("Prompt list change externally notified. Sending notification.");
 		this.getModernEraNotifier?.()?.promptsChanged();
 		await broadcastNotification({
 			servers: this.getSdkServers(),
@@ -24738,7 +24902,6 @@ var MCPServer = class extends MCPServerBase {
 	httpServerInstances = /* @__PURE__ */ new Map();
 	resourceOptions;
 	hasUiResources = false;
-	definedPrompts;
 	promptOptions;
 	jsonSchemaValidator;
 	mapAuthInfoToUser;
@@ -24951,9 +25114,6 @@ var MCPServer = class extends MCPServerBase {
 		this.prompts = new ServerPromptActions({
 			getLogger: () => this.logger,
 			getSdkServers: () => this.getAllSdkServers(),
-			clearDefinedPrompts: () => {
-				this.definedPrompts = void 0;
-			},
 			getModernEraNotifier
 		});
 		this.toolActions = new ServerToolActions({
@@ -25613,13 +25773,11 @@ var MCPServer = class extends MCPServerBase {
 		if (!capturedPromptOptions) return;
 		if (capturedPromptOptions.listPrompts) serverInstance.setRequestHandler("prompts/list", async (_request, ctx) => {
 			this.logger.debug("Handling ListPrompts request");
-			if (this.definedPrompts) return { prompts: this.definedPrompts };
-			else try {
+			try {
 				const prompts = await capturedPromptOptions.listPrompts({ extra: toMCPRequestHandlerExtra(ctx) });
 				for (const prompt of prompts) PromptSchema.parse(prompt);
-				this.definedPrompts = prompts;
-				this.logger.debug("Fetched and cached prompts", { count: this.definedPrompts.length });
-				return { prompts: this.definedPrompts };
+				this.logger.debug("Fetched prompts", { count: prompts.length });
+				return { prompts };
 			} catch (error) {
 				this.logger.error("Error fetching prompts via listPrompts():", { error: error instanceof Error ? error.message : String(error) });
 				throw error;
@@ -25628,12 +25786,11 @@ var MCPServer = class extends MCPServerBase {
 		if (capturedPromptOptions.getPromptMessages) serverInstance.setRequestHandler("prompts/get", async (request, ctx) => {
 			const startTime = Date.now();
 			const { name, arguments: args } = request.params;
-			if (!this.definedPrompts) {
-				const prompts = await this.promptOptions?.listPrompts?.({ extra: toMCPRequestHandlerExtra(ctx) });
-				if (!prompts) throw new Error("Failed to load prompts");
-				this.definedPrompts = prompts;
-			}
-			const prompt = this.definedPrompts?.find((p) => p.name === name);
+			const extra = toMCPRequestHandlerExtra(ctx);
+			const prompts = await capturedPromptOptions.listPrompts?.({ extra });
+			if (!prompts) throw new Error("Failed to load prompts");
+			for (const definedPrompt of prompts) PromptSchema.parse(definedPrompt);
+			const prompt = prompts.find((p) => p.name === name);
 			if (!prompt) throw new Error(`Prompt "${name}" not found`);
 			if (prompt.arguments) {
 				for (const arg of prompt.arguments) if (arg.required && (args?.[arg.name] === void 0 || args?.[arg.name] === null)) throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Missing required argument: ${arg.name}`);
@@ -25644,7 +25801,7 @@ var MCPServer = class extends MCPServerBase {
 					name,
 					version: prompt.version,
 					args,
-					extra: toMCPRequestHandlerExtra(ctx)
+					extra
 				});
 				const duration = Date.now() - startTime;
 				this.logger.info("Prompt retrieved successfully", {
@@ -27127,6 +27284,6 @@ function createIntrospectionValidator(introspectionEndpoint, clientCredentials)
 	};
 }
 //#endregion
-export { InMemoryOAuthStorage, InternalMastraMCPClient, MCPClient, MCPClientServerProxy, MCPOAuthClientProvider, MCPServer, MCP_CALL_TOOL_CONTENT, UnauthorizedError, auth, buildDiscoveryUrls, createIntrospectionValidator, createOAuthCallbackServer, createOAuthMiddleware, createSimpleTokenProvider, createStaticTokenValidator, discoverAuthorizationServerMetadata, discoverOAuthMetadata, discoverOAuthProtectedResourceMetadata, exchangeAuthorization, extractBearerToken, extractResourceMetadataUrl, generateProtectedResourceMetadata, generateWWWAuthenticateHeader, getCallbackUrlCandidates, parseErrorResponse, refreshAuthorization, registerClient, selectResourceURL, startAuthorization };
+export { InMemoryOAuthStorage, InternalMastraMCPClient, MCPClient, MCPClientServerProxy, MCPOAuthClientProvider, MCPServer, MCP_CALL_TOOL_CONTENT, MCP_CALL_TOOL_META, UnauthorizedError, auth, buildDiscoveryUrls, createIntrospectionValidator, createOAuthCallbackServer, createOAuthMiddleware, createSimpleTokenProvider, createStaticTokenValidator, discoverAuthorizationServerMetadata, discoverOAuthMetadata, discoverOAuthProtectedResourceMetadata, exchangeAuthorization, extractBearerToken, extractResourceMetadataUrl, generateProtectedResourceMetadata, generateWWWAuthenticateHeader, getCallbackUrlCandidates, getMcpCallToolContent, getMcpCallToolMeta, parseErrorResponse, refreshAuthorization, registerClient, selectResourceURL, startAuthorization };
 
 //# sourceMappingURL=index.js.map