@od-oneapp/ai-platform 0.1.0

package/dist/client-CpacYDIE.mjs

@@ -0,0 +1,882 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { r as getErrorCode } from "./errors-Dtn-UeRi.mjs";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+import { logError, logInfo, logWarn } from "@od-oneapp/shared/logs";
+import "server-only";
+
+//#region src/tools/mcp/ai-sdk-error-integration.ts
+/**
+* @fileoverview ai-sdk-error-integration.ts
+*/
+/**
+* Enhanced error class that conforms to AI SDK v6 error handling patterns
+*/
+var AISDKCompatibleMCPError = class AISDKCompatibleMCPError extends Error {
+	errorType;
+	timestamp;
+	recoverable;
+	metadata;
+	constructor(message, errorType = "unknown-error", originalError, metadata = {}, recoverable = false) {
+		super(message);
+		this.name = "AISDKCompatibleMCPError";
+		this.errorType = errorType;
+		this.timestamp = /* @__PURE__ */ new Date();
+		this.recoverable = recoverable;
+		this.metadata = {
+			...metadata,
+			originalError: originalError?.message,
+			originalStack: originalError?.stack
+		};
+		if (Error.captureStackTrace) Error.captureStackTrace(this, AISDKCompatibleMCPError);
+	}
+	/**
+	* Convert to AI SDK error format for logging
+	*/
+	toAISDKFormat() {
+		return {
+			name: this.name,
+			message: this.message,
+			errorType: this.errorType,
+			timestamp: this.timestamp.toISOString(),
+			recoverable: this.recoverable,
+			metadata: this.metadata,
+			stack: this.stack
+		};
+	}
+};
+/**
+* Error handler factory for MCP operations
+* Creates standardized error handlers that integrate with AI SDK v6 patterns
+*/
+var MCPErrorHandlerFactory = class {
+	clientName;
+	operationContext;
+	constructor(clientName, operationContext = "mcp-operation") {
+		this.clientName = clientName;
+		this.operationContext = operationContext;
+	}
+	/**
+	* Create an onUncaughtError handler for AI SDK v6 integration
+	*/
+	createUncaughtErrorHandler(cleanupFn, options = {}) {
+		const { enableRecovery = false, maxRecoveryAttempts = 1, logLevel = "error" } = options;
+		let recoveryAttempts = 0;
+		return (error) => {
+			const aiError = this.convertToAISDKError(error);
+			(logLevel === "warn" ? logWarn : logLevel === "info" ? logInfo : logError)(`MCP uncaught error in ${this.operationContext}`, {
+				operation: "mcp_uncaught_error_handler",
+				metadata: {
+					clientName: this.clientName,
+					errorType: aiError.errorType,
+					recoverable: aiError.recoverable,
+					recoveryAttempts,
+					maxRecoveryAttempts,
+					...aiError.metadata
+				},
+				error: aiError
+			});
+			if (enableRecovery && aiError.recoverable && recoveryAttempts < maxRecoveryAttempts) {
+				recoveryAttempts++;
+				logInfo(`Attempting recovery for MCP error (attempt ${recoveryAttempts}/${maxRecoveryAttempts})`, {
+					operation: "mcp_error_recovery_attempt",
+					metadata: {
+						clientName: this.clientName,
+						recoveryAttempt: recoveryAttempts,
+						errorType: aiError.errorType
+					}
+				});
+				return;
+			}
+			(async () => {
+				try {
+					await cleanupFn();
+				} catch (cleanupError) {
+					logError(`Failed to cleanup after uncaught error in ${this.operationContext}`, {
+						operation: "mcp_cleanup_after_uncaught_error",
+						metadata: {
+							clientName: this.clientName,
+							originalError: aiError.message,
+							cleanupError: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+						},
+						error: cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError))
+					});
+				}
+			})();
+		};
+	}
+	/**
+	* Create a stream error handler for AI SDK v6 streaming integration
+	*/
+	createStreamErrorHandler(cleanupFn, onStreamError) {
+		return (error) => {
+			const aiError = this.convertToAISDKError(error, "transport-error");
+			logError(`MCP stream error in ${this.operationContext}`, {
+				operation: "mcp_stream_error_handler",
+				metadata: {
+					clientName: this.clientName,
+					errorType: aiError.errorType,
+					streamContext: this.operationContext,
+					...aiError.metadata
+				},
+				error: aiError
+			});
+			if (onStreamError) try {
+				onStreamError(aiError);
+			} catch (callbackError) {
+				logError(`Stream error callback failed in ${this.operationContext}`, {
+					operation: "mcp_stream_error_callback_failure",
+					metadata: {
+						clientName: this.clientName,
+						callbackError: callbackError instanceof Error ? callbackError.message : String(callbackError)
+					},
+					error: callbackError instanceof Error ? callbackError : new Error(String(callbackError))
+				});
+			}
+			(async () => {
+				try {
+					await cleanupFn();
+				} catch (cleanupError) {
+					logError(`Failed to cleanup after stream error in ${this.operationContext}`, {
+						operation: "mcp_stream_cleanup_error",
+						metadata: {
+							clientName: this.clientName,
+							originalError: aiError.message,
+							cleanupError: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+						},
+						error: cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError))
+					});
+				}
+			})();
+		};
+	}
+	/**
+	* Create a finish handler for proper AI SDK v6 lifecycle management
+	*/
+	createFinishHandler(cleanupFn, successCallback) {
+		return async () => {
+			try {
+				await cleanupFn();
+				logInfo(`MCP operation completed successfully in ${this.operationContext}`, {
+					operation: "mcp_finish_handler_success",
+					metadata: {
+						clientName: this.clientName,
+						operationContext: this.operationContext
+					}
+				});
+				if (successCallback) try {
+					successCallback();
+				} catch (callbackError) {
+					logWarn(`Success callback failed in ${this.operationContext}`, {
+						operation: "mcp_success_callback_failure",
+						metadata: {
+							clientName: this.clientName,
+							callbackError: callbackError instanceof Error ? callbackError.message : String(callbackError)
+						}
+					});
+				}
+			} catch (error) {
+				const aiError = this.convertToAISDKError(error instanceof Error ? error : new Error(String(error)));
+				logError(`MCP finish handler failed in ${this.operationContext}`, {
+					operation: "mcp_finish_handler_error",
+					metadata: {
+						clientName: this.clientName,
+						errorType: aiError.errorType,
+						...aiError.metadata
+					},
+					error: aiError
+				});
+				throw aiError;
+			}
+		};
+	}
+	/**
+	* Convert generic error to AI SDK compatible error
+	*/
+	convertToAISDKError(error, defaultType = "unknown-error") {
+		if (error instanceof AISDKCompatibleMCPError) return error;
+		let errorType = defaultType;
+		let recoverable = false;
+		if (error.message.includes("ECONNREFUSED") || error.message.includes("ENOTFOUND")) {
+			errorType = "connection-error";
+			recoverable = true;
+		} else if (error.message.includes("timeout") || error.message.includes("TIMEOUT")) {
+			errorType = "timeout-error";
+			recoverable = true;
+		} else if (error.message.includes("transport") || error.message.includes("Transport")) {
+			errorType = "transport-error";
+			recoverable = true;
+		} else if (error.message.includes("validation") || error.message.includes("invalid")) {
+			errorType = "validation-error";
+			recoverable = false;
+		} else if (error.message.includes("resource") || error.message.includes("limit")) {
+			errorType = "resource-exhausted";
+			recoverable = true;
+		} else if (error.message.includes("tool") || error.message.includes("execution")) {
+			errorType = "tool-execution-error";
+			recoverable = false;
+		}
+		return new AISDKCompatibleMCPError(error.message, errorType, error, {
+			clientName: this.clientName,
+			operationContext: this.operationContext,
+			originalErrorName: error.name
+		}, recoverable);
+	}
+};
+/**
+* Utility functions for AI SDK v6 error integration
+*/
+const MCPErrorUtils = {
+	createErrorContext(clientName, operation) {
+		return new MCPErrorHandlerFactory(clientName, operation);
+	},
+	isRecoverableError(error) {
+		if (error instanceof AISDKCompatibleMCPError) return error.recoverable;
+		return [
+			"ECONNREFUSED",
+			"ENOTFOUND",
+			"TIMEOUT",
+			"timeout",
+			"network",
+			"temporary",
+			"rate limit",
+			"throttle"
+		].some((pattern) => error.message.toLowerCase().includes(pattern.toLowerCase()));
+	},
+	extractErrorMetadata(error) {
+		const metadata = {
+			errorName: error.name,
+			errorMessage: error.message,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (error instanceof AISDKCompatibleMCPError) {
+			metadata.errorType = error.errorType;
+			metadata.recoverable = error.recoverable;
+			metadata.customMetadata = error.metadata;
+		}
+		const errorCode = getErrorCode(error);
+		if (errorCode) metadata.errorCode = errorCode;
+		const errorDetails = error;
+		if (typeof errorDetails.errno === "string" || typeof errorDetails.errno === "number") metadata.errno = errorDetails.errno;
+		if (typeof errorDetails.syscall === "string") metadata.syscall = errorDetails.syscall;
+		return metadata;
+	}
+};
+
+//#endregion
+//#region src/tools/mcp/client.ts
+/**
+* @fileoverview client.ts
+*/
+var client_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_HEALTH_CHECK_CONFIG: () => DEFAULT_HEALTH_CHECK_CONFIG,
+	DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
+	MCPConnectionError: () => MCPConnectionError,
+	MCPHealthMonitor: () => MCPHealthMonitor,
+	MCPHealthStatus: () => MCPHealthStatus,
+	MCPRequestManager: () => MCPRequestManager,
+	MCPRetryableError: () => MCPRetryableError,
+	MCPTransportError: () => MCPTransportError,
+	createMCPToolsForRequest: () => createMCPToolsForRequest,
+	createMCPToolsFromConfigs: () => createMCPToolsFromConfigs,
+	createTransportFromConfig: () => createTransportFromConfig,
+	globalMCPHealthMonitor: () => globalMCPHealthMonitor,
+	withRetryAndTimeout: () => withRetryAndTimeout
+});
+/**
+* Default retry configuration
+*/
+const DEFAULT_RETRY_CONFIG = {
+	maxAttempts: 3,
+	initialDelayMs: 1e3,
+	maxDelayMs: 1e4,
+	backoffMultiplier: 2,
+	retryableErrors: [
+		"ECONNREFUSED",
+		"ENOTFOUND",
+		"TIMEOUT",
+		"NETWORK_ERROR",
+		"CONNECTION_LOST"
+	]
+};
+/**
+* Default health check configuration
+*/
+const DEFAULT_HEALTH_CHECK_CONFIG = {
+	enabled: true,
+	intervalMs: 6e4,
+	timeoutMs: 5e3,
+	failureThreshold: 3,
+	recoveryThreshold: 2
+};
+/**
+* Health status for MCP servers
+*/
+let MCPHealthStatus = /* @__PURE__ */ function(MCPHealthStatus) {
+	MCPHealthStatus["HEALTHY"] = "healthy";
+	MCPHealthStatus["DEGRADED"] = "degraded";
+	MCPHealthStatus["UNHEALTHY"] = "unhealthy";
+	MCPHealthStatus["UNKNOWN"] = "unknown";
+	return MCPHealthStatus;
+}({});
+/**
+* MCP Error types for better error handling
+*/
+var MCPConnectionError = class extends Error {
+	constructor(message, clientName, transportType, originalError) {
+		super(message);
+		this.clientName = clientName;
+		this.transportType = transportType;
+		this.originalError = originalError;
+		this.name = "MCPConnectionError";
+	}
+};
+var MCPTransportError = class extends Error {
+	constructor(message, transportType, originalError) {
+		super(message);
+		this.transportType = transportType;
+		this.originalError = originalError;
+		this.name = "MCPTransportError";
+	}
+};
+var MCPRetryableError = class extends Error {
+	constructor(message, attempt, maxAttempts, originalError) {
+		super(message);
+		this.attempt = attempt;
+		this.maxAttempts = maxAttempts;
+		this.originalError = originalError;
+		this.name = "MCPRetryableError";
+	}
+};
+/**
+* Utility function to check if an error is retryable
+*/
+function isRetryableError(error, retryableErrors) {
+	const errorMessage = error.message.toUpperCase();
+	const errorCode = getErrorCode(error);
+	return retryableErrors.some((pattern) => errorMessage.includes(pattern.toUpperCase()) || errorCode === pattern);
+}
+/**
+* Utility function to calculate exponential backoff delay
+*/
+function calculateDelay(attempt, config) {
+	const delay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1);
+	return Math.min(delay, config.maxDelayMs);
+}
+/**
+* Utility function to sleep for a given duration
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Timeout wrapper that cancels operations after a specified duration
+*/
+async function withTimeout(operation, timeoutMs, context = "MCP operation") {
+	const timeoutPromise = new Promise((resolve, reject) => {
+		setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`${context} timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	return Promise.race([operation(), timeoutPromise]);
+}
+/**
+* Enhanced retry wrapper with exponential backoff
+*/
+async function withRetry(operation, config = DEFAULT_RETRY_CONFIG, context = "MCP operation") {
+	let lastError;
+	for (let attempt = 1; attempt <= config.maxAttempts; attempt++) try {
+		return await operation();
+	} catch (error) {
+		lastError = error instanceof Error ? error : new Error(String(error));
+		if (attempt === config.maxAttempts || !isRetryableError(lastError, config.retryableErrors)) {
+			logError(`${context} failed after ${attempt} attempts`, {
+				operation: "mcp_retry_exhausted",
+				metadata: {
+					context,
+					attempt,
+					maxAttempts: config.maxAttempts,
+					error: lastError.message
+				},
+				error: lastError
+			});
+			throw lastError;
+		}
+		const delay = calculateDelay(attempt, config);
+		logWarn(`${context} failed, retrying in ${delay}ms (attempt ${attempt}/${config.maxAttempts})`, {
+			operation: "mcp_retry_attempt",
+			metadata: {
+				context,
+				attempt,
+				maxAttempts: config.maxAttempts,
+				delayMs: delay,
+				error: lastError.message
+			}
+		});
+		await sleep(delay);
+	}
+	throw lastError || /* @__PURE__ */ new Error(`${context} failed after all retry attempts`);
+}
+/**
+* Combined retry and timeout wrapper
+*/
+async function withRetryAndTimeout(operation, retryConfig = DEFAULT_RETRY_CONFIG, timeoutMs, context = "MCP operation") {
+	return withRetry(timeoutMs ? () => withTimeout(operation, timeoutMs, context) : operation, retryConfig, context);
+}
+/**
+* MCP Server Health Monitor
+* Tracks health status of MCP servers and provides graceful degradation
+*/
+var MCPHealthMonitor = class {
+	healthStatuses = /* @__PURE__ */ new Map();
+	healthCheckIntervals = /* @__PURE__ */ new Map();
+	/**
+	* Start health monitoring for a client configuration
+	*/
+	startMonitoring(config) {
+		const healthConfig = config.healthCheck ?? DEFAULT_HEALTH_CHECK_CONFIG;
+		if (!healthConfig.enabled) return;
+		this.healthStatuses.set(config.name, {
+			status: MCPHealthStatus.UNKNOWN,
+			lastCheck: /* @__PURE__ */ new Date(),
+			consecutiveFailures: 0,
+			consecutiveSuccesses: 0
+		});
+		const intervalId = setInterval(() => {
+			this.performHealthCheck(config);
+		}, healthConfig.intervalMs);
+		this.healthCheckIntervals.set(config.name, intervalId);
+		this.performHealthCheck(config);
+	}
+	/**
+	* Stop health monitoring for a client
+	*/
+	stopMonitoring(clientName) {
+		const intervalId = this.healthCheckIntervals.get(clientName);
+		if (intervalId) {
+			clearInterval(intervalId);
+			this.healthCheckIntervals.delete(clientName);
+		}
+		this.healthStatuses.delete(clientName);
+	}
+	/**
+	* Get current health status for a client
+	*/
+	getHealthStatus(clientName) {
+		return this.healthStatuses.get(clientName);
+	}
+	/**
+	* Check if a client is currently healthy
+	*/
+	isHealthy(clientName) {
+		return this.healthStatuses.get(clientName)?.status === MCPHealthStatus.HEALTHY;
+	}
+	/**
+	* Check if a client should be excluded due to poor health
+	*/
+	shouldExclude(clientName) {
+		return this.healthStatuses.get(clientName)?.status === MCPHealthStatus.UNHEALTHY;
+	}
+	/**
+	* Perform a health check for a specific client
+	*/
+	async performHealthCheck(config) {
+		const healthConfig = config.healthCheck ?? DEFAULT_HEALTH_CHECK_CONFIG;
+		const startTime = Date.now();
+		let result;
+		try {
+			await withTimeout(async () => {
+				const tempClient = await createMCPClient({ transport: createTransportFromConfig(config.transport) });
+				try {
+					await tempClient.tools();
+					await tempClient.close();
+				} catch (toolError) {
+					await tempClient.close();
+					throw toolError;
+				}
+			}, healthConfig.timeoutMs, `Health check for ${config.name}`);
+			const responseTime = Date.now() - startTime;
+			const currentStatus = this.healthStatuses.get(config.name);
+			result = {
+				status: MCPHealthStatus.HEALTHY,
+				lastCheck: /* @__PURE__ */ new Date(),
+				consecutiveFailures: 0,
+				consecutiveSuccesses: (currentStatus?.consecutiveSuccesses ?? 0) + 1,
+				responseTimeMs: responseTime
+			};
+		} catch (error) {
+			const consecutiveFailures = (this.healthStatuses.get(config.name)?.consecutiveFailures ?? 0) + 1;
+			let newStatus;
+			if (consecutiveFailures >= healthConfig.failureThreshold) newStatus = MCPHealthStatus.UNHEALTHY;
+			else if (consecutiveFailures > 1) newStatus = MCPHealthStatus.DEGRADED;
+			else newStatus = MCPHealthStatus.DEGRADED;
+			result = {
+				status: newStatus,
+				lastCheck: /* @__PURE__ */ new Date(),
+				consecutiveFailures,
+				consecutiveSuccesses: 0,
+				error: error instanceof Error ? error.message : String(error)
+			};
+			logWarn(`Health check failed for MCP client '${config.name}'`, {
+				operation: "mcp_health_check_failed",
+				metadata: {
+					clientName: config.name,
+					consecutiveFailures,
+					status: newStatus,
+					error: result.error
+				}
+			});
+		}
+		const previousStatus = this.healthStatuses.get(config.name);
+		this.healthStatuses.set(config.name, result);
+		if (previousStatus && previousStatus.status !== result.status) logWarn(`MCP client '${config.name}' health status changed: ${previousStatus.status} → ${result.status}`, {
+			operation: "mcp_health_status_change",
+			metadata: {
+				clientName: config.name,
+				previousStatus: previousStatus.status,
+				newStatus: result.status,
+				consecutiveFailures: result.consecutiveFailures,
+				consecutiveSuccesses: result.consecutiveSuccesses
+			}
+		});
+	}
+	/**
+	* Get summary of all client health statuses
+	*/
+	getHealthSummary() {
+		return Object.fromEntries(this.healthStatuses);
+	}
+	/**
+	* Cleanup all monitoring
+	*/
+	cleanup() {
+		for (const intervalId of this.healthCheckIntervals.values()) clearInterval(intervalId);
+		this.healthCheckIntervals.clear();
+		this.healthStatuses.clear();
+	}
+};
+/**
+* Global health monitor instance
+*/
+const globalMCPHealthMonitor = new MCPHealthMonitor();
+/**
+* Validate transport configuration at runtime
+*/
+function validateTransportConfig(transportConfig) {
+	switch (transportConfig.type) {
+		case "stdio":
+			if (!transportConfig.command) throw new MCPTransportError("Command is required for stdio transport", "stdio");
+			break;
+		case "sse": {
+			const url = resolveRemoteUrl(transportConfig);
+			if (!url) throw new MCPTransportError("URL is required for SSE transport", "sse");
+			try {
+				new URL(url);
+			} catch {
+				throw new MCPTransportError("Invalid URL format for SSE transport", "sse");
+			}
+			break;
+		}
+		case "http": {
+			const url = resolveRemoteUrl(transportConfig);
+			if (!url) throw new MCPTransportError("HTTP URL is required for HTTP transport", "http");
+			try {
+				new URL(url);
+			} catch {
+				throw new MCPTransportError("Invalid HTTP URL format for HTTP transport", "http");
+			}
+			break;
+		}
+		default: throw new MCPTransportError(`Unsupported transport type: ${getTransportTypeLabel(transportConfig)}`, "unknown");
+	}
+}
+/**
+* Create transport instance from configuration with proper typing and validation
+*/
+function createTransportFromConfig(transportConfig) {
+	validateTransportConfig(transportConfig);
+	switch (transportConfig.type) {
+		case "stdio":
+			const baseEnv = Object.entries(process.env).reduce((acc, [key, value]) => {
+				if (typeof value === "string") acc[key] = value;
+				return acc;
+			}, {});
+			return new Experimental_StdioMCPTransport({
+				command: transportConfig.command ?? "node",
+				args: transportConfig.args ?? [],
+				cwd: transportConfig.cwd,
+				stderr: transportConfig.stderr,
+				env: {
+					...baseEnv,
+					...process.env.PERPLEXITY_API_KEY && { PERPLEXITY_API_KEY: process.env.PERPLEXITY_API_KEY },
+					...process.env.OPENAI_API_KEY && { OPENAI_API_KEY: process.env.OPENAI_API_KEY },
+					...process.env.ANTHROPIC_API_KEY && { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
+					...transportConfig.env
+				}
+			});
+		case "sse": return buildRemoteTransport("sse", transportConfig);
+		case "http": return buildRemoteTransport("http", transportConfig);
+		default: throw new MCPTransportError(`Unsupported transport type: ${getTransportTypeLabel(transportConfig)}`, "unknown");
+	}
+}
+function resolveRemoteUrl(transportConfig) {
+	return transportConfig.url ?? transportConfig.httpUrl;
+}
+function getTransportTypeLabel(transportConfig) {
+	return typeof transportConfig.type === "string" ? transportConfig.type : "unknown";
+}
+function buildRemoteTransport(type, transportConfig) {
+	const url = resolveRemoteUrl(transportConfig);
+	if (!url) throw new MCPTransportError(`URL is required for ${type} transport`, type);
+	const headers = { ...transportConfig.headers };
+	if (type === "http" && transportConfig.sessionId) headers["x-mcp-session-id"] = transportConfig.sessionId;
+	return {
+		type,
+		url,
+		headers: Object.keys(headers).length > 0 ? headers : void 0,
+		authProvider: transportConfig.authProvider
+	};
+}
+/**
+* Per-request MCP client manager following Next.js documentation pattern with AI SDK v6 integration
+* Creates clients per request and cleans them up automatically with proper error handling
+*/
+var MCPRequestManager = class {
+	clients = [];
+	tools = {};
+	errorHandlers = /* @__PURE__ */ new Map();
+	async addClient(config) {
+		const retryConfig = config.retry ?? DEFAULT_RETRY_CONFIG;
+		const timeoutMs = config.timeoutMs || 3e4;
+		const context = `MCP client creation (${config.name})`;
+		const errorHandler = new MCPErrorHandlerFactory(config.name, context);
+		this.errorHandlers.set(config.name, errorHandler);
+		if (globalMCPHealthMonitor.shouldExclude(config.name)) if (config.gracefulDegradation) {
+			logWarn(`Skipping unhealthy MCP client '${config.name}'`, {
+				operation: "mcp_skip_unhealthy",
+				metadata: {
+					clientName: config.name,
+					healthStatus: globalMCPHealthMonitor.getHealthStatus(config.name)
+				}
+			});
+			return;
+		} else throw new AISDKCompatibleMCPError(`MCP client '${config.name}' is marked as unhealthy`, "connection-error", void 0, {
+			clientName: config.name,
+			transportType: config.transport.type,
+			healthStatus: globalMCPHealthMonitor.getHealthStatus(config.name)
+		}, true);
+		try {
+			await withRetryAndTimeout(async () => {
+				const client = await createMCPClient({ transport: createTransportFromConfig(config.transport) });
+				this.clients.push(client);
+				const clientTools = await withRetryAndTimeout(() => client.tools(), retryConfig, timeoutMs, `MCP tools retrieval (${config.name})`);
+				Object.assign(this.tools, clientTools);
+				globalMCPHealthMonitor.startMonitoring(config);
+			}, retryConfig, timeoutMs, context);
+		} catch (error) {
+			const originalError = error instanceof Error ? error : new Error(String(error));
+			const aiError = new AISDKCompatibleMCPError(`Failed to create MCP client '${config.name}' after retries`, "connection-error", originalError, {
+				clientName: config.name,
+				transportType: config.transport.type,
+				retryAttempts: retryConfig.maxAttempts,
+				timeoutMs
+			}, MCPErrorUtils.isRecoverableError(originalError));
+			if (config.gracefulDegradation) {
+				logWarn(`MCP client '${config.name}' failed, continuing with degraded functionality`, {
+					operation: "mcp_graceful_degradation",
+					metadata: {
+						clientName: config.name,
+						transportType: config.transport.type,
+						error: aiError.message,
+						errorType: aiError.errorType,
+						recoverable: aiError.recoverable,
+						...MCPErrorUtils.extractErrorMetadata(originalError)
+					}
+				});
+				return;
+			}
+			throw aiError;
+		}
+	}
+	getTools() {
+		return this.tools;
+	}
+	async close() {
+		const closePromises = this.clients.map(async (client, index) => {
+			try {
+				await client.close();
+			} catch (error) {
+				logWarn(`Failed to close MCP client ${index}`, {
+					operation: "mcp_client_close",
+					metadata: {
+						clientIndex: index,
+						error: error instanceof Error ? error.message : String(error)
+					}
+				});
+			}
+		});
+		await Promise.all(closePromises);
+		this.clients = [];
+		this.tools = {};
+	}
+	/**
+	* Get health summary for all managed clients
+	*/
+	getHealthSummary() {
+		return globalMCPHealthMonitor.getHealthSummary();
+	}
+	/**
+	* Create AI SDK v6 compatible error handlers for all managed clients
+	*/
+	createAISDKErrorHandlers() {
+		const onUncaughtError = (error) => {
+			for (const [, errorHandler] of this.errorHandlers.entries()) errorHandler.createUncaughtErrorHandler(() => this.close(), {
+				enableRecovery: true,
+				maxRecoveryAttempts: 1
+			})(error);
+		};
+		const onFinish = async () => {
+			try {
+				await this.close();
+			} catch (error) {
+				throw new AISDKCompatibleMCPError("Failed to close MCP clients on finish", "resource-exhausted", error instanceof Error ? error : new Error(String(error)), {
+					clientCount: this.clients.length,
+					operation: "finish_cleanup"
+				}, false);
+			}
+		};
+		const onStreamError = (error) => {
+			for (const [, errorHandler] of this.errorHandlers.entries()) errorHandler.createStreamErrorHandler(() => this.close())(error);
+		};
+		return {
+			onUncaughtError,
+			onFinish,
+			onStreamError
+		};
+	}
+};
+/**
+* Create MCP tools for a single request (following Next.js docs pattern)
+* This creates clients per request and returns cleanup functions
+*/
+async function createMCPToolsForRequest(configs) {
+	const manager = new MCPRequestManager();
+	for (const config of configs) await manager.addClient(config);
+	return {
+		tools: manager.getTools(),
+		clients: manager.clients,
+		cleanup: () => manager.close()
+	};
+}
+/**
+* Create MCP tools following the exact Next.js documentation pattern
+* This function matches the pattern shown in the official AI SDK docs:
+* https://sdk.vercel.ai/docs/ai-sdk-ui/mcp-tools (Next.js usage)
+* https://sdk.vercel.ai/docs/ai-sdk-core/mcp-tools (Node.js usage)
+*
+* Next.js streamText example from official docs:
+* ```typescript
+* const toolSetOne = await stdioClient.tools();
+* const toolSetTwo = await sseClient.tools();
+* const toolSetThree = await customClient.tools();
+* const tools = {
+*   ...toolSetOne,
+*   ...toolSetTwo,
+*   ...toolSetThree, // note: this approach causes subsequent tool sets to override tools with the same name
+* };
+*
+* const response = streamText({
+*   model: openai('gpt-4o'),
+*   tools,
+*   prompt,
+*   onFinish: async () => {
+*     await stdioClient.close();
+*     await sseClient.close();
+*     await customClient.close();
+*   },
+* });
+* ```
+*/
+async function createMCPToolsFromConfigs(configs, options = {}) {
+	const clients = [];
+	const toolSets = [];
+	const clientPromises = configs.map(async (config) => {
+		const retryConfig = config.retry ?? DEFAULT_RETRY_CONFIG;
+		const timeoutMs = config.timeoutMs || 3e4;
+		const enableGracefulDegradation = config.gracefulDegradation ?? options.gracefulDegradation ?? false;
+		try {
+			return await withRetryAndTimeout(async () => {
+				const client = await createMCPClient({ transport: createTransportFromConfig(config.transport) });
+				try {
+					return {
+						client,
+						toolSet: await withRetryAndTimeout(() => client.tools(), retryConfig, timeoutMs, `MCP tools retrieval (${config.name})`),
+						config
+					};
+				} catch (error) {
+					try {
+						await client.close();
+					} catch (closeError) {
+						logError(`Failed to close failed client ${config.name}`, {
+							operation: "mcp_client_cleanup",
+							metadata: { clientName: config.name },
+							error: closeError instanceof Error ? closeError : new Error(String(closeError))
+						});
+					}
+					throw error;
+				}
+			}, retryConfig, timeoutMs, `MCP client creation (${config.name})`);
+		} catch (error) {
+			const mcpError = new MCPConnectionError(`Failed to create MCP client '${config.name}' after retries`, config.name, config.transport.type, error instanceof Error ? error : new Error(String(error)));
+			if (enableGracefulDegradation) {
+				logWarn(`Failed to create MCP client ${config.name}, continuing with degraded functionality`, {
+					operation: "mcp_client_creation_degraded",
+					metadata: {
+						clientName: config.name,
+						transportType: config.transport.type,
+						retryAttempts: retryConfig.maxAttempts,
+						timeoutMs,
+						error: mcpError.message
+					}
+				});
+				return null;
+			} else throw mcpError;
+		}
+	});
+	const results = await Promise.all(clientPromises);
+	for (const result of results) if (result) {
+		clients.push(result.client);
+		toolSets.push(result.toolSet);
+	}
+	const tools = mergeToolSets(toolSets);
+	const closeAllClients = async () => {
+		const closePromises = clients.map(async (client, index) => {
+			try {
+				await client.close();
+			} catch (error) {
+				logWarn(`Failed to close MCP client ${index}`, {
+					operation: "mcp_client_close",
+					metadata: {
+						clientIndex: index,
+						error: error instanceof Error ? error.message : String(error)
+					}
+				});
+			}
+		});
+		await Promise.all(closePromises);
+	};
+	return {
+		tools,
+		clients,
+		closeAllClients
+	};
+}
+function mergeToolSets(toolSets) {
+	const merged = {};
+	for (const toolSet of toolSets) Object.assign(merged, toolSet);
+	return merged;
+}
+
+//#endregion
+export { MCPErrorUtils as _, MCPHealthStatus as a, MCPTransportError as c, createMCPToolsFromConfigs as d, createTransportFromConfig as f, MCPErrorHandlerFactory as g, AISDKCompatibleMCPError as h, MCPHealthMonitor as i, client_exports as l, withRetryAndTimeout as m, DEFAULT_RETRY_CONFIG as n, MCPRequestManager as o, globalMCPHealthMonitor as p, MCPConnectionError as r, MCPRetryableError as s, DEFAULT_HEALTH_CHECK_CONFIG as t, createMCPToolsForRequest as u };
+//# sourceMappingURL=client-CpacYDIE.mjs.map