@od-oneapp/ai-platform 0.1.0

package/dist/transport-selector-D-Ib05X1.mjs

@@ -0,0 +1,1936 @@
+import { d as createMCPToolsFromConfigs, f as createTransportFromConfig, g as MCPErrorHandlerFactory, h as AISDKCompatibleMCPError, m as withRetryAndTimeout, n as DEFAULT_RETRY_CONFIG, p as globalMCPHealthMonitor, r as MCPConnectionError } from "./client-CpacYDIE.mjs";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { createHash } from "node:crypto";
+import { logError, logInfo, logWarn } from "@od-oneapp/shared/logs";
+import "server-only";
+
+//#region src/tools/mcp/stream-lifecycle-integration.ts
+/**
+* @fileoverview stream-lifecycle-integration.ts
+*/
+/**
+* AI SDK v6 Stream Lifecycle Integration for MCP
+*
+* Provides comprehensive stream lifecycle management that integrates with AI SDK v6
+* streaming patterns and ensures proper resource cleanup throughout the stream lifecycle.
+*
+* Key Features:
+* - Stream initialization with MCP client setup
+* - Streaming event handling (onStart, onProgress, onComplete)
+* - Stream error recovery and fallback mechanisms
+* - Proper resource cleanup at stream end
+* - Integration with AI SDK v6 streaming callbacks
+* - Memory management during long streams
+* - Stream abort handling
+*/
+/**
+* Stream lifecycle phases for proper state management
+*/
+let StreamLifecyclePhase = /* @__PURE__ */ function(StreamLifecyclePhase) {
+	StreamLifecyclePhase["INITIALIZING"] = "initializing";
+	StreamLifecyclePhase["CONNECTED"] = "connected";
+	StreamLifecyclePhase["STREAMING"] = "streaming";
+	StreamLifecyclePhase["PAUSED"] = "paused";
+	StreamLifecyclePhase["COMPLETING"] = "completing";
+	StreamLifecyclePhase["COMPLETED"] = "completed";
+	StreamLifecyclePhase["ERROR"] = "error";
+	StreamLifecyclePhase["ABORTED"] = "aborted";
+	StreamLifecyclePhase["CLEANUP"] = "cleanup";
+	return StreamLifecyclePhase;
+}({});
+/**
+* Default stream lifecycle configuration
+*/
+const DEFAULT_STREAM_LIFECYCLE_CONFIG = {
+	enableHealthChecks: true,
+	healthCheckIntervalMs: 3e4,
+	streamTimeoutMs: 3e5,
+	maxRetryAttempts: 3,
+	backoffStrategy: "exponential",
+	enableMemoryMonitoring: true,
+	maxMemoryUsageMB: 200,
+	enableAbortHandling: true,
+	gracefulShutdownTimeoutMs: 1e4
+};
+/**
+* Stream lifecycle manager for MCP clients
+* Handles the complete lifecycle of AI SDK streams with MCP tool integration
+*/
+var MCPStreamLifecycleManager = class {
+	phase = StreamLifecyclePhase.INITIALIZING;
+	eventHistory = [];
+	config;
+	clients = [];
+	tools = {};
+	closeAllClients = async () => {};
+	errorHandlers = [];
+	abortController;
+	healthCheckInterval;
+	memoryMonitorInterval;
+	streamStartTime;
+	constructor(clientConfigs, config = {}) {
+		this.clientConfigs = clientConfigs;
+		this.config = {
+			...DEFAULT_STREAM_LIFECYCLE_CONFIG,
+			...config
+		};
+		this.logEvent(StreamLifecyclePhase.INITIALIZING, { clientCount: clientConfigs.length });
+	}
+	/**
+	* Initialize the stream lifecycle with MCP clients
+	*/
+	async initialize() {
+		try {
+			this.streamStartTime = /* @__PURE__ */ new Date();
+			this.logEvent(StreamLifecyclePhase.INITIALIZING, { startTime: this.streamStartTime.toISOString() });
+			if (this.config.enableAbortHandling) this.abortController = new AbortController();
+			const { createMCPToolsFromConfigs } = await import("./client-CpacYDIE.mjs").then((n) => n.l);
+			const result = await createMCPToolsFromConfigs(this.clientConfigs, { gracefulDegradation: true });
+			this.clients = result.clients;
+			this.tools = result.tools;
+			this.closeAllClients = result.closeAllClients;
+			this.errorHandlers = this.clientConfigs.map((config) => new MCPErrorHandlerFactory(config.name, "stream-lifecycle"));
+			this.phase = StreamLifecyclePhase.CONNECTED;
+			this.logEvent(StreamLifecyclePhase.CONNECTED, {
+				clientCount: this.clients.length,
+				toolCount: Object.keys(this.tools).length
+			});
+			this.startMonitoring();
+			const streamCallbacks = this.createStreamCallbacks();
+			return {
+				tools: this.tools,
+				clients: this.clients,
+				streamCallbacks
+			};
+		} catch (error) {
+			this.phase = StreamLifecyclePhase.ERROR;
+			const aiError = new AISDKCompatibleMCPError("Failed to initialize MCP stream lifecycle", "connection-error", error instanceof Error ? error : new Error(String(error)), { phase: this.phase }, true);
+			this.logEvent(StreamLifecyclePhase.ERROR, { error: aiError.message });
+			throw aiError;
+		}
+	}
+	/**
+	* Create AI SDK v6 compatible stream callbacks
+	*/
+	createStreamCallbacks() {
+		return {
+			onStart: () => {
+				this.phase = StreamLifecyclePhase.STREAMING;
+				this.logEvent(StreamLifecyclePhase.STREAMING, { elapsedMs: this.getElapsedTime() });
+				logInfo("MCP stream started", {
+					operation: "mcp_stream_start",
+					metadata: {
+						clientCount: this.clients.length,
+						toolCount: Object.keys(this.tools).length,
+						phase: this.phase
+					}
+				});
+			},
+			onProgress: (data) => {
+				if (this.config.enableMemoryMonitoring) this.checkMemoryUsage();
+				if (this.abortController?.signal.aborted) {
+					this.handleAbort();
+					return;
+				}
+				this.logEvent(StreamLifecyclePhase.STREAMING, {
+					progressData: data,
+					elapsedMs: this.getElapsedTime()
+				});
+			},
+			onFinish: async (event) => {
+				this.phase = StreamLifecyclePhase.COMPLETING;
+				this.logEvent(StreamLifecyclePhase.COMPLETING, {
+					finishEvent: event,
+					elapsedMs: this.getElapsedTime()
+				});
+				try {
+					await this.performGracefulCleanup();
+					this.phase = StreamLifecyclePhase.COMPLETED;
+					this.logEvent(StreamLifecyclePhase.COMPLETED, {
+						totalElapsedMs: this.getElapsedTime(),
+						eventCount: this.eventHistory.length
+					});
+					logInfo("MCP stream completed successfully", {
+						operation: "mcp_stream_complete",
+						metadata: {
+							totalElapsedMs: this.getElapsedTime(),
+							toolCallCount: event?.toolResults?.length ?? 0,
+							usage: event?.usage
+						}
+					});
+				} catch (error) {
+					this.phase = StreamLifecyclePhase.ERROR;
+					const aiError = new AISDKCompatibleMCPError("Failed to complete MCP stream lifecycle", "resource-exhausted", error instanceof Error ? error : new Error(String(error)), {
+						phase: this.phase,
+						elapsedMs: this.getElapsedTime()
+					}, false);
+					this.logEvent(StreamLifecyclePhase.ERROR, { error: aiError.message });
+					logError("MCP stream completion failed", {
+						operation: "mcp_stream_completion_error",
+						error: aiError,
+						metadata: { phase: this.phase }
+					});
+					throw aiError;
+				}
+			},
+			onError: async (error) => {
+				this.phase = StreamLifecyclePhase.ERROR;
+				const aiError = new AISDKCompatibleMCPError("MCP stream error occurred", "tool-execution-error", error, {
+					phase: this.phase,
+					elapsedMs: this.getElapsedTime(),
+					errorLocation: "stream_callback"
+				}, true);
+				this.logEvent(StreamLifecyclePhase.ERROR, {
+					error: aiError.message,
+					errorType: aiError.errorType
+				});
+				logError("MCP stream error", {
+					operation: "mcp_stream_error",
+					error: aiError,
+					metadata: {
+						phase: this.phase,
+						clientCount: this.clients.length
+					}
+				});
+				try {
+					await this.performEmergencyCleanup();
+				} catch (cleanupError) {
+					logError("Emergency cleanup failed after stream error", {
+						operation: "mcp_emergency_cleanup_failure",
+						error: cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)),
+						metadata: { originalError: aiError.message }
+					});
+				}
+			},
+			onUncaughtError: (error) => {
+				this.phase = StreamLifecyclePhase.ERROR;
+				const aiError = new AISDKCompatibleMCPError("Uncaught error in MCP stream", "unknown-error", error, {
+					phase: this.phase,
+					elapsedMs: this.getElapsedTime(),
+					errorLocation: "uncaught"
+				}, false);
+				this.logEvent(StreamLifecyclePhase.ERROR, {
+					error: aiError.message,
+					errorType: "uncaught"
+				});
+				logError("Uncaught MCP stream error", {
+					operation: "mcp_stream_uncaught_error",
+					error: aiError,
+					metadata: {
+						phase: this.phase,
+						stackTrace: error.stack
+					}
+				});
+				this.errorHandlers.forEach((handler) => {
+					handler.createUncaughtErrorHandler(() => this.performEmergencyCleanup(), { enableRecovery: false })(error);
+				});
+			},
+			onAbort: () => {
+				this.handleAbort();
+			}
+		};
+	}
+	/**
+	* Handle stream abortion
+	*/
+	handleAbort() {
+		this.phase = StreamLifecyclePhase.ABORTED;
+		this.logEvent(StreamLifecyclePhase.ABORTED, {
+			elapsedMs: this.getElapsedTime(),
+			reason: "user_requested"
+		});
+		logWarn("MCP stream aborted", {
+			operation: "mcp_stream_abort",
+			metadata: {
+				phase: this.phase,
+				elapsedMs: this.getElapsedTime()
+			}
+		});
+		this.performAsyncCleanup("mcp_abort_cleanup_failure");
+	}
+	/**
+	* Start monitoring services
+	*/
+	startMonitoring() {
+		if (this.config.enableHealthChecks) this.healthCheckInterval = setInterval(() => {
+			this.performHealthCheck();
+		}, this.config.healthCheckIntervalMs);
+		if (this.config.enableMemoryMonitoring) this.memoryMonitorInterval = setInterval(() => {
+			this.checkMemoryUsage();
+		}, 1e4);
+	}
+	/**
+	* Perform health check on MCP clients
+	*/
+	performHealthCheck() {
+		const healthStatus = this.clients.length > 0 ? "healthy" : "degraded";
+		this.logEvent(this.phase, { healthCheck: {
+			status: healthStatus,
+			clientCount: this.clients.length,
+			toolCount: Object.keys(this.tools).length,
+			elapsedMs: this.getElapsedTime()
+		} });
+		if (healthStatus === "degraded") logWarn("MCP stream health degraded", {
+			operation: "mcp_stream_health_check",
+			metadata: {
+				clientCount: this.clients.length,
+				phase: this.phase
+			}
+		});
+	}
+	/**
+	* Check memory usage
+	*/
+	checkMemoryUsage() {
+		if (typeof process !== "undefined" && process.memoryUsage) {
+			const heapUsedMB = process.memoryUsage().heapUsed / 1024 / 1024;
+			if (heapUsedMB > this.config.maxMemoryUsageMB) {
+				logWarn("MCP stream memory usage high", {
+					operation: "mcp_stream_memory_warning",
+					metadata: {
+						heapUsedMB: Math.round(heapUsedMB),
+						maxMemoryUsageMB: this.config.maxMemoryUsageMB,
+						phase: this.phase
+					}
+				});
+				if (global.gc) global.gc();
+			}
+		}
+	}
+	/**
+	* Perform graceful cleanup
+	*/
+	async performGracefulCleanup() {
+		this.phase = StreamLifecyclePhase.CLEANUP;
+		this.logEvent(StreamLifecyclePhase.CLEANUP, {
+			cleanupType: "graceful",
+			elapsedMs: this.getElapsedTime()
+		});
+		if (this.healthCheckInterval) {
+			clearInterval(this.healthCheckInterval);
+			this.healthCheckInterval = void 0;
+		}
+		if (this.memoryMonitorInterval) {
+			clearInterval(this.memoryMonitorInterval);
+			this.memoryMonitorInterval = void 0;
+		}
+		const cleanupPromise = this.closeAllClients();
+		const timeoutPromise = new Promise((resolve, reject) => {
+			setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Graceful cleanup timeout"));
+			}, this.config.gracefulShutdownTimeoutMs);
+		});
+		try {
+			await Promise.race([cleanupPromise, timeoutPromise]);
+			logInfo("MCP stream graceful cleanup completed", {
+				operation: "mcp_stream_graceful_cleanup",
+				metadata: { elapsedMs: this.getElapsedTime() }
+			});
+		} catch (error) {
+			logWarn("Graceful cleanup timeout, performing emergency cleanup", {
+				operation: "mcp_graceful_cleanup_timeout",
+				metadata: { error: error instanceof Error ? error.message : String(error) }
+			});
+			await this.performEmergencyCleanup();
+		}
+	}
+	/**
+	* Perform emergency cleanup
+	*/
+	async performEmergencyCleanup() {
+		this.logEvent(StreamLifecyclePhase.CLEANUP, {
+			cleanupType: "emergency",
+			elapsedMs: this.getElapsedTime()
+		});
+		if (this.healthCheckInterval) {
+			clearInterval(this.healthCheckInterval);
+			this.healthCheckInterval = void 0;
+		}
+		if (this.memoryMonitorInterval) {
+			clearInterval(this.memoryMonitorInterval);
+			this.memoryMonitorInterval = void 0;
+		}
+		this.performAsyncCleanup("mcp_emergency_cleanup_error");
+		logWarn("MCP stream emergency cleanup performed", {
+			operation: "mcp_stream_emergency_cleanup",
+			metadata: { elapsedMs: this.getElapsedTime() }
+		});
+	}
+	/**
+	* Log lifecycle event
+	*/
+	logEvent(phase, metadata) {
+		const event = {
+			phase,
+			timestamp: /* @__PURE__ */ new Date(),
+			metadata: {
+				...metadata,
+				clientConfigs: this.clientConfigs.map((c) => c.name)
+			}
+		};
+		this.eventHistory.push(event);
+		if (this.eventHistory.length > 100) this.eventHistory = this.eventHistory.slice(-100);
+	}
+	/**
+	* Get elapsed time since stream start
+	*/
+	getElapsedTime() {
+		if (!this.streamStartTime) return 0;
+		return Date.now() - this.streamStartTime.getTime();
+	}
+	/**
+	* Get current lifecycle status
+	*/
+	getStatus() {
+		return {
+			phase: this.phase,
+			elapsedMs: this.getElapsedTime(),
+			clientCount: this.clients.length,
+			toolCount: Object.keys(this.tools).length,
+			eventCount: this.eventHistory.length,
+			recentEvents: this.eventHistory.slice(-10)
+		};
+	}
+	/**
+	* Request abort
+	*/
+	requestAbort() {
+		if (this.abortController && !this.abortController.signal.aborted) this.abortController.abort();
+	}
+	/**
+	* Perform async cleanup with proper error handling
+	*/
+	async performAsyncCleanup(operationType) {
+		try {
+			await this.closeAllClients();
+		} catch (error) {
+			logError("Cleanup failed", {
+				operation: operationType,
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+		}
+	}
+};
+/**
+* Factory function to create MCP stream lifecycle manager
+*/
+function createMCPStreamLifecycleManager(clientConfigs, config) {
+	return new MCPStreamLifecycleManager(clientConfigs, config);
+}
+
+//#endregion
+//#region src/tools/mcp/next-pattern.ts
+/**
+* @fileoverview next-pattern.ts
+*/
+/**
+* Helper function to handle async cleanup with error logging
+*/
+async function performCleanupWithLogging(cleanupFn, originalError, operationType) {
+	try {
+		await cleanupFn();
+	} catch (closeError) {
+		logError("Failed to close MCP clients after error", {
+			operation: operationType,
+			metadata: {
+				originalError: originalError.message,
+				closeError: closeError instanceof Error ? closeError.message : String(closeError)
+			},
+			error: closeError instanceof Error ? closeError : new Error(String(closeError))
+		});
+	}
+}
+/**
+* Next.js streamText-compatible MCP tools factory
+* Follows the exact pattern from Next.js documentation:
+* https://sdk.vercel.ai/docs/ai-sdk-ui/mcp-tools
+*
+* This implementation supports:
+* - ✅ stdio transport (local processes)
+* - ✅ SSE transport (Server-Sent Events)
+* - ✅ HTTP transport (StreamableHTTP from @modelcontextprotocol/sdk)
+* - ✅ Per-request client creation and cleanup
+* - ✅ Graceful degradation when servers are unavailable
+* - ✅ Environment-based configuration
+* - ✅ AI SDK v6 error handling integration
+* - ✅ Stream lifecycle management
+* - ✅ Uncaught error handling
+*
+* Usage in streamText with AI SDK v6 error handling:
+* ```typescript
+* const { tools, closeAllClients, onUncaughtError } = await createMCPToolsForStreamText(configs);
+*
+* const result = streamText({
+*   model: openai('gpt-4o'),
+*   tools: {
+*     // Built-in tools
+*     someBuiltinTool,
+*     // MCP tools (following official docs pattern)
+*     ...tools,
+*   },
+*   prompt: 'Your prompt here',
+*   onFinish: async () => {
+*     await closeAllClients();
+*   },
+*   onError: (error) => {
+*     closeAllClients().catch((closeError) => {
+*       logError('Failed to close MCP clients on error', closeError instanceof Error ? closeError : new Error(String(closeError)));
+*     });
+*   },
+*   // AI SDK v6 uncaught error handling
+*   onUncaughtError: onUncaughtError,
+* });
+* ```
+*/
+async function createMCPToolsForStreamText(configs) {
+	const result = await createMCPToolsFromConfigs(configs, { gracefulDegradation: true });
+	const onUncaughtError = (error) => {
+		logError("MCP uncaught error detected", {
+			operation: "mcp_uncaught_error",
+			metadata: {
+				errorType: error.name,
+				errorMessage: error.message,
+				clientCount: result.clients.length,
+				toolCount: Object.keys(result.tools).length
+			},
+			error
+		});
+		performCleanupWithLogging(() => result.closeAllClients(), error, "mcp_cleanup_after_uncaught_error");
+	};
+	const onFinish = async () => {
+		try {
+			await result.closeAllClients();
+			logInfo("MCP clients successfully closed on finish", {
+				operation: "mcp_finish_cleanup",
+				metadata: {
+					clientCount: result.clients.length,
+					toolCount: Object.keys(result.tools).length
+				}
+			});
+		} catch (error) {
+			logError("Failed to close MCP clients on finish", {
+				operation: "mcp_finish_cleanup_error",
+				metadata: {
+					clientCount: result.clients.length,
+					error: error instanceof Error ? error.message : String(error)
+				},
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+			throw error;
+		}
+	};
+	return {
+		...result,
+		onUncaughtError,
+		onFinish
+	};
+}
+/**
+* Simplified factory for basic MCP setup with AI SDK v6 integration
+* Automatically handles common error cases and provides error callbacks
+*/
+async function createMCPToolsWithDefaults(configs, options = {}) {
+	const { gracefulDegradation = true, logErrors = true, includeAISDKCallbacks = true } = options;
+	const errors = [];
+	let tools = {};
+	let clients = [];
+	let closeAllClients = async () => {};
+	let isAvailable = false;
+	let onUncaughtError;
+	let onFinish;
+	if (configs.length === 0) {
+		if (logErrors) logInfo("No MCP configs provided", { operation: "mcp_tools_creation" });
+		return {
+			tools,
+			clients,
+			closeAllClients,
+			isAvailable,
+			errors,
+			onUncaughtError,
+			onFinish
+		};
+	}
+	try {
+		const result = await createMCPToolsFromConfigs(configs, { gracefulDegradation });
+		({tools, clients, closeAllClients} = result);
+		isAvailable = Object.keys(tools).length > 0;
+		if (includeAISDKCallbacks) {
+			onUncaughtError = (error) => {
+				if (logErrors) logError("MCP uncaught error in defaults setup", {
+					operation: "mcp_defaults_uncaught_error",
+					metadata: {
+						errorType: error.name,
+						errorMessage: error.message,
+						clientCount: clients.length,
+						toolCount: Object.keys(tools).length
+					},
+					error
+				});
+				if (logErrors) performCleanupWithLogging(closeAllClients, error, "mcp_defaults_cleanup_error");
+				else (async () => {
+					try {
+						await closeAllClients();
+					} catch {}
+				})();
+			};
+			onFinish = async () => {
+				try {
+					await closeAllClients();
+					if (logErrors) logInfo("MCP clients closed successfully on finish (defaults)", {
+						operation: "mcp_defaults_finish_cleanup",
+						metadata: {
+							clientCount: clients.length,
+							toolCount: Object.keys(tools).length
+						}
+					});
+				} catch (error) {
+					if (logErrors) logError("Failed to close MCP clients on finish (defaults)", {
+						operation: "mcp_defaults_finish_error",
+						metadata: {
+							clientCount: clients.length,
+							error: error instanceof Error ? error.message : String(error)
+						},
+						error: error instanceof Error ? error : new Error(String(error))
+					});
+					throw error;
+				}
+			};
+		}
+		if (logErrors && isAvailable) logInfo(`MCP tools loaded: ${Object.keys(tools).join(", ")}`, {
+			toolCount: Object.keys(tools).length,
+			toolNames: Object.keys(tools),
+			operation: "mcp_tools_creation"
+		});
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown MCP error";
+		errors.push(errorMessage);
+		if (logErrors) logError("MCP tools failed to load", {
+			operation: "mcp_tools_creation",
+			errorMessage,
+			error: error instanceof Error ? error : new Error(errorMessage)
+		});
+		if (!gracefulDegradation) throw error;
+	}
+	return {
+		tools,
+		clients,
+		closeAllClients,
+		isAvailable,
+		errors,
+		onUncaughtError,
+		onFinish
+	};
+}
+/**
+* Test MCP connectivity without creating persistent connections
+*/
+async function testMCPConnectivity(configs) {
+	const results = [];
+	for (const config of configs) try {
+		const { tools, closeAllClients } = await createMCPToolsFromConfigs([config]);
+		const toolCount = Object.keys(tools).length;
+		results.push({
+			name: config.name,
+			success: true,
+			toolCount
+		});
+		await closeAllClients();
+	} catch (error) {
+		results.push({
+			name: config.name,
+			success: false,
+			error: error instanceof Error ? error.message : "Unknown error",
+			toolCount: 0
+		});
+	}
+	return {
+		results,
+		overallSuccess: results.every((r) => r.success)
+	};
+}
+/**
+* Advanced MCP tools factory with full AI SDK v6 stream lifecycle management
+* Provides comprehensive error handling, monitoring, and resource management
+*/
+async function createMCPToolsWithStreamLifecycle(configs, lifecycleConfig) {
+	const lifecycleManager = createMCPStreamLifecycleManager(configs, lifecycleConfig);
+	const { tools, clients, streamCallbacks } = await lifecycleManager.initialize();
+	const closeAllClients = async () => {
+		try {
+			await streamCallbacks.onFinish({});
+		} catch (error) {
+			logError("Failed to close MCP clients via lifecycle manager", {
+				operation: "mcp_lifecycle_cleanup_error",
+				error: error instanceof Error ? error : new Error(String(error)),
+				metadata: {
+					clientCount: clients.length,
+					toolCount: Object.keys(tools).length
+				}
+			});
+			throw error;
+		}
+	};
+	const compatibleOnFinish = async () => {
+		await streamCallbacks.onFinish({});
+	};
+	return {
+		tools,
+		clients,
+		closeAllClients,
+		onUncaughtError: streamCallbacks.onUncaughtError,
+		onFinish: compatibleOnFinish,
+		streamCallbacks,
+		lifecycleManager: {
+			getStatus: lifecycleManager.getStatus.bind(lifecycleManager),
+			requestAbort: lifecycleManager.requestAbort.bind(lifecycleManager)
+		}
+	};
+}
+
+//#endregion
+//#region src/tools/mcp/connection-manager.ts
+/**
+* @fileoverview connection-manager.ts
+*/
+/**
+* Enhanced MCP connection manager with pooling and monitoring
+* Provides connection reuse, health checking, and monitoring for production use
+*/
+var MCPConnectionManager = class {
+	connections = /* @__PURE__ */ new Map();
+	config;
+	healthCheckTimer;
+	events = {};
+	constructor(config = {}) {
+		this.config = {
+			maxConnections: 10,
+			connectionTimeout: 3e4,
+			healthCheckInterval: 6e4,
+			retryAttempts: 3,
+			retryDelay: 1e3,
+			...config
+		};
+		this.startHealthChecking();
+	}
+	/**
+	* Register event listeners
+	*/
+	on(event, listener) {
+		this.events[event] = listener;
+	}
+	/**
+	* Get or create a connection for the given config
+	*/
+	async getConnection(config) {
+		const key = this.getConnectionKey(config);
+		let connection = this.connections.get(key);
+		if (connection) {
+			connection.lastUsed = /* @__PURE__ */ new Date();
+			connection.useCount += 1;
+			return connection;
+		}
+		if (this.connections.size >= this.config.maxConnections) await this.evictOldestConnection();
+		connection = await this.createConnection(config);
+		this.connections.set(key, connection);
+		this.events.created?.(config);
+		return connection;
+	}
+	/**
+	* Get all tools from active connections
+	*/
+	async getAllTools() {
+		const allTools = {};
+		for (const connection of this.connections.values()) if (connection.isHealthy) Object.assign(allTools, connection.tools);
+		return allTools;
+	}
+	/**
+	* Get connection statistics
+	*/
+	getStats() {
+		const connections = Array.from(this.connections.values());
+		const healthyConnections = connections.filter((c) => c.isHealthy);
+		const totalUseCount = connections.reduce((sum, c) => sum + c.useCount, 0);
+		const createdDates = connections.map((c) => c.createdAt);
+		const oldestConnection = createdDates.length > 0 ? new Date(Math.min(...createdDates.map((d) => d.getTime()))) : void 0;
+		const newestConnection = createdDates.length > 0 ? new Date(Math.max(...createdDates.map((d) => d.getTime()))) : void 0;
+		return {
+			totalConnections: connections.length,
+			healthyConnections: healthyConnections.length,
+			totalUseCount,
+			oldestConnection,
+			newestConnection
+		};
+	}
+	/**
+	* Close specific connection
+	*/
+	async closeConnection(config) {
+		const key = this.getConnectionKey(config);
+		const connection = this.connections.get(key);
+		if (connection) {
+			try {
+				await connection.client.close();
+			} catch (error) {
+				logWarn(`Failed to close MCP connection ${config.name}`, {
+					connectionName: config.name,
+					error: error instanceof Error ? error.message : String(error),
+					operation: "mcp_close_connection"
+				});
+			}
+			this.connections.delete(key);
+			this.events.destroyed?.(config);
+		}
+	}
+	/**
+	* Close all connections and cleanup
+	*/
+	async closeAll() {
+		if (this.healthCheckTimer) clearInterval(this.healthCheckTimer);
+		const closePromises = Array.from(this.connections.values()).map(async (connection) => {
+			try {
+				await connection.client.close();
+			} catch (error) {
+				logWarn(`Failed to close MCP connection ${connection.config.name}`, {
+					connectionName: connection.config.name,
+					error: error instanceof Error ? error.message : String(error),
+					operation: "mcp_close_all_connections"
+				});
+			}
+		});
+		await Promise.all(closePromises);
+		this.connections.clear();
+	}
+	/**
+	* Perform health check on all connections
+	*/
+	async performHealthCheck() {
+		const healthCheckPromises = Array.from(this.connections.values()).map(async (connection) => {
+			try {
+				await connection.client.tools();
+				connection.isHealthy = true;
+				connection.lastHealthCheck = /* @__PURE__ */ new Date();
+				this.events.healthCheck?.(connection.config, true);
+			} catch (error) {
+				connection.isHealthy = false;
+				connection.lastHealthCheck = /* @__PURE__ */ new Date();
+				this.events.healthCheck?.(connection.config, false);
+				this.events.error?.(connection.config, error instanceof Error ? error : new Error(String(error)));
+				const key = this.getConnectionKey(connection.config);
+				this.connections.delete(key);
+				try {
+					await connection.client.close();
+				} catch (closeError) {
+					logWarn(`Failed to close unhealthy connection ${connection.config.name}`, {
+						connectionName: connection.config.name,
+						error: closeError instanceof Error ? closeError.message : String(closeError),
+						operation: "mcp_close_unhealthy_connection"
+					});
+				}
+			}
+		});
+		await Promise.all(healthCheckPromises);
+	}
+	getConnectionKey(config) {
+		const { transport } = config;
+		const normalizedTransport = transport.type === "stdio" ? {
+			type: transport.type,
+			command: transport.command,
+			args: transport.args,
+			cwd: transport.cwd
+		} : {
+			type: transport.type,
+			url: transport.url ?? transport.httpUrl,
+			sessionId: transport.sessionId
+		};
+		const hash = createHash("sha256").update(JSON.stringify(normalizedTransport)).digest("hex").slice(0, 12);
+		return `${config.name}-${transport.type}-${hash}`;
+	}
+	async createConnection(config) {
+		let attempt = 0;
+		let lastError;
+		while (attempt < this.config.retryAttempts) try {
+			const client = await createMCPClient({ transport: createTransportFromConfig(config.transport) });
+			return {
+				config,
+				client,
+				tools: await client.tools(),
+				createdAt: /* @__PURE__ */ new Date(),
+				lastUsed: /* @__PURE__ */ new Date(),
+				useCount: 1,
+				isHealthy: true,
+				lastHealthCheck: /* @__PURE__ */ new Date()
+			};
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			attempt++;
+			if (attempt < this.config.retryAttempts) await new Promise((resolve) => setTimeout(resolve, this.config.retryDelay * attempt));
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("All connection attempts failed");
+	}
+	async evictOldestConnection() {
+		let oldestConnection = null;
+		for (const [key, connection] of this.connections.entries()) if (!oldestConnection || connection.lastUsed < oldestConnection.connection.lastUsed) oldestConnection = {
+			key,
+			connection
+		};
+		if (oldestConnection) await this.closeConnection(oldestConnection.connection.config);
+	}
+	startHealthChecking() {
+		this.healthCheckTimer = setInterval(() => {
+			(async () => {
+				try {
+					await this.performHealthCheck();
+				} catch (error) {
+					logWarn("Health check failed", {
+						error: error instanceof Error ? error.message : String(error),
+						operation: "mcp_health_check"
+					});
+				}
+			})();
+		}, this.config.healthCheckInterval);
+	}
+};
+/**
+* Global connection manager instance
+* Provides a singleton for connection pooling across the application
+*/
+let globalConnectionManager = null;
+function getGlobalConnectionManager(config) {
+	if (!globalConnectionManager) globalConnectionManager = new MCPConnectionManager(config);
+	return globalConnectionManager;
+}
+/**
+* Create MCP tools with connection pooling
+* This provides better performance and resource management for production use
+*/
+async function createPooledMCPTools(configs, options = {}) {
+	const manager = options.useGlobalPool ? getGlobalConnectionManager(options.poolConfig) : new MCPConnectionManager(options.poolConfig);
+	const tools = {};
+	for (const config of configs) try {
+		const connection = await manager.getConnection(config);
+		Object.assign(tools, connection.tools);
+	} catch (error) {
+		logWarn(`Failed to get connection for ${config.name}`, {
+			connectionName: config.name,
+			error: error instanceof Error ? error.message : String(error),
+			operation: "mcp_get_connection"
+		});
+	}
+	return {
+		tools,
+		manager
+	};
+}
+
+//#endregion
+//#region src/tools/mcp/tool-cache.ts
+/**
+* @fileoverview tool-cache.ts
+*/
+/**
+* Default tool cache configuration
+*/
+const DEFAULT_CACHE_CONFIG = {
+	enabled: true,
+	maxEntries: 1e3,
+	ttlMs: 3e5,
+	maxMemoryMB: 50,
+	compressionEnabled: false
+};
+/**
+* MCP Tool Cache
+* Caches frequently used MCP tools to improve performance
+*/
+var MCPToolCache = class {
+	cache = /* @__PURE__ */ new Map();
+	config;
+	stats = {
+		hits: 0,
+		misses: 0,
+		totalAccessTime: 0,
+		accessCount: 0
+	};
+	cleanupInterval;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CACHE_CONFIG,
+			...config
+		};
+		if (this.config.enabled) this.startCleanupTask();
+	}
+	/**
+	* Get tools from cache if available
+	*/
+	get(clientConfig) {
+		if (!this.config.enabled) return null;
+		const key = this.getCacheKey(clientConfig);
+		const entry = this.cache.get(key);
+		if (!entry) {
+			this.stats.misses++;
+			return null;
+		}
+		const now = /* @__PURE__ */ new Date();
+		if (now.getTime() - entry.createdAt.getTime() > this.config.ttlMs) {
+			this.cache.delete(key);
+			this.stats.misses++;
+			return null;
+		}
+		entry.lastAccessed = now;
+		entry.accessCount++;
+		this.stats.hits++;
+		return entry.tools;
+	}
+	/**
+	* Store tools in cache
+	*/
+	set(clientConfig, tools) {
+		if (!this.config.enabled) return;
+		const key = this.getCacheKey(clientConfig);
+		const size = this.estimateSize(tools);
+		const now = /* @__PURE__ */ new Date();
+		if (this.shouldEvictForMemory(size)) this.evictLeastRecentlyUsed();
+		if (this.cache.size >= this.config.maxEntries) this.evictOldestEntry();
+		const entry = {
+			tools,
+			createdAt: now,
+			lastAccessed: now,
+			accessCount: 1,
+			size
+		};
+		this.cache.set(key, entry);
+	}
+	/**
+	* Clear all cached tools for a specific client
+	*/
+	invalidate(clientConfig) {
+		const key = this.getCacheKey(clientConfig);
+		this.cache.delete(key);
+	}
+	/**
+	* Clear all cached tools
+	*/
+	clear() {
+		this.cache.clear();
+		this.resetStats();
+	}
+	/**
+	* Get cache statistics
+	*/
+	getStats() {
+		const entries = Array.from(this.cache.values());
+		const totalSize = entries.reduce((sum, entry) => sum + entry.size, 0);
+		const totalRequests = this.stats.hits + this.stats.misses;
+		const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+		const avgAccessTime = this.stats.accessCount > 0 ? this.stats.totalAccessTime / this.stats.accessCount : 0;
+		return {
+			hits: this.stats.hits,
+			misses: this.stats.misses,
+			entries: this.cache.size,
+			totalSize,
+			hitRate,
+			avgAccessTime,
+			oldestEntry: entries.length > 0 ? new Date(Math.min(...entries.map((e) => e.createdAt.getTime()))) : void 0,
+			newestEntry: entries.length > 0 ? new Date(Math.max(...entries.map((e) => e.createdAt.getTime()))) : void 0
+		};
+	}
+	/**
+	* Generate cache key for client configuration
+	*/
+	getCacheKey(clientConfig) {
+		return `mcp:${clientConfig.name}:${clientConfig.transport.type}:${JSON.stringify(clientConfig.transport)}`;
+	}
+	/**
+	* Estimate memory size of tools object
+	*/
+	estimateSize(tools) {
+		try {
+			return JSON.stringify(tools).length * 2;
+		} catch {
+			return 1024;
+		}
+	}
+	/**
+	* Check if we should evict entries to stay within memory limits
+	*/
+	shouldEvictForMemory(newEntrySize) {
+		const currentSize = Array.from(this.cache.values()).reduce((sum, entry) => sum + entry.size, 0);
+		const maxSizeBytes = this.config.maxMemoryMB * 1024 * 1024;
+		return currentSize + newEntrySize > maxSizeBytes;
+	}
+	/**
+	* Evict least recently used entries
+	*/
+	evictLeastRecentlyUsed() {
+		if (this.cache.size === 0) return;
+		const entries = Array.from(this.cache.entries()).sort(([, a], [, b]) => a.lastAccessed.getTime() - b.lastAccessed.getTime());
+		const toRemove = Math.max(1, Math.floor(entries.length * .25));
+		for (let i = 0; i < toRemove; i++) {
+			const entry = entries[i];
+			if (!entry) continue;
+			const [key] = entry;
+			this.cache.delete(key);
+		}
+		logWarn(`Evicted ${toRemove} LRU entries from MCP tool cache`, {
+			operation: "mcp_cache_lru_eviction",
+			metadata: {
+				evictedCount: toRemove,
+				remainingEntries: this.cache.size
+			}
+		});
+	}
+	/**
+	* Evict oldest entry
+	*/
+	evictOldestEntry() {
+		if (this.cache.size === 0) return;
+		let oldestKey = null;
+		let oldestTime = Date.now();
+		for (const [key, entry] of this.cache.entries()) if (entry.createdAt.getTime() < oldestTime) {
+			oldestTime = entry.createdAt.getTime();
+			oldestKey = key;
+		}
+		if (oldestKey) this.cache.delete(oldestKey);
+	}
+	/**
+	* Start periodic cleanup task
+	*/
+	startCleanupTask() {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanupExpiredEntries();
+		}, 6e4);
+	}
+	/**
+	* Clean up expired entries
+	*/
+	cleanupExpiredEntries() {
+		const now = /* @__PURE__ */ new Date();
+		const expiredKeys = [];
+		for (const [key, entry] of this.cache.entries()) if (now.getTime() - entry.createdAt.getTime() > this.config.ttlMs) expiredKeys.push(key);
+		for (const key of expiredKeys) this.cache.delete(key);
+		if (expiredKeys.length > 0) logWarn(`Cleaned up ${expiredKeys.length} expired entries from MCP tool cache`, {
+			operation: "mcp_cache_cleanup",
+			metadata: {
+				expiredCount: expiredKeys.length,
+				remainingEntries: this.cache.size
+			}
+		});
+	}
+	/**
+	* Reset statistics
+	*/
+	resetStats() {
+		this.stats = {
+			hits: 0,
+			misses: 0,
+			totalAccessTime: 0,
+			accessCount: 0
+		};
+	}
+	/**
+	* Disable caching
+	*/
+	disable() {
+		this.config.enabled = false;
+		this.clear();
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+	}
+	/**
+	* Enable caching
+	*/
+	enable() {
+		this.config.enabled = true;
+		this.startCleanupTask();
+	}
+	/**
+	* Cleanup resources
+	*/
+	cleanup() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+		this.clear();
+	}
+};
+/**
+* Global MCP tool cache instance
+*/
+const globalMCPToolCache = new MCPToolCache();
+
+//#endregion
+//#region src/tools/mcp/connection-pool.ts
+/**
+* @fileoverview connection-pool.ts
+*/
+/**
+* Default connection pool configuration
+*/
+const DEFAULT_POOL_CONFIG = {
+	maxConnections: 10,
+	minConnections: 2,
+	idleTimeoutMs: 3e5,
+	connectionTimeoutMs: 3e4,
+	healthCheckEnabled: true
+};
+/**
+* MCP Connection Pool
+* Manages a pool of reusable MCP client connections for better performance
+*/
+var MCPConnectionPool = class {
+	connections = /* @__PURE__ */ new Map();
+	poolConfig;
+	cleanupInterval;
+	constructor(config = {}) {
+		this.poolConfig = {
+			...DEFAULT_POOL_CONFIG,
+			...config
+		};
+		this.startCleanupTask();
+	}
+	/**
+	* Get a connection from the pool or create a new one
+	*/
+	async getConnection(config) {
+		const poolKey = this.getPoolKey(config);
+		let pool = this.connections.get(poolKey);
+		if (!pool) {
+			pool = [];
+			this.connections.set(poolKey, pool);
+		}
+		const availableConnection = pool.find((conn) => !conn.inUse);
+		if (availableConnection) {
+			availableConnection.inUse = true;
+			availableConnection.lastUsed = /* @__PURE__ */ new Date();
+			return availableConnection;
+		}
+		if (pool.length >= this.poolConfig.maxConnections) return this.waitForAvailableConnection(poolKey);
+		return this.createConnection(config, poolKey);
+	}
+	/**
+	* Return a connection to the pool
+	*/
+	releaseConnection(connection) {
+		connection.inUse = false;
+		connection.lastUsed = /* @__PURE__ */ new Date();
+	}
+	/**
+	* Get tools from a pooled connection with caching
+	*/
+	async getTools(config) {
+		const cachedTools = globalMCPToolCache.get(config);
+		if (cachedTools) return cachedTools;
+		if (this.poolConfig.healthCheckEnabled && globalMCPHealthMonitor.shouldExclude(config.name)) if (config.gracefulDegradation) {
+			logWarn(`Skipping unhealthy MCP client '${config.name}' in pool`, {
+				operation: "mcp_pool_skip_unhealthy",
+				metadata: {
+					clientName: config.name,
+					healthStatus: globalMCPHealthMonitor.getHealthStatus(config.name)
+				}
+			});
+			return emptyToolSet();
+		} else throw new MCPConnectionError(`MCP client '${config.name}' is marked as unhealthy`, config.name, config.transport.type);
+		let connection = null;
+		try {
+			connection = await this.getConnection(config);
+			const tools = await withRetryAndTimeout(() => {
+				if (!connection) throw new Error("Connection is null");
+				return connection.client.tools();
+			}, config.retry ?? DEFAULT_RETRY_CONFIG, config.timeoutMs || this.poolConfig.connectionTimeoutMs, `MCP pooled tools retrieval (${config.name})`);
+			globalMCPToolCache.set(config, tools);
+			return tools;
+		} catch (error) {
+			if (connection) await this.removeConnection(connection);
+			const mcpError = new MCPConnectionError(`Failed to get tools from pooled MCP client '${config.name}'`, config.name, config.transport.type, error instanceof Error ? error : new Error(String(error)));
+			if (config.gracefulDegradation) {
+				logWarn(`Pooled MCP client '${config.name}' failed, continuing with degraded functionality`, {
+					operation: "mcp_pool_degraded",
+					metadata: {
+						clientName: config.name,
+						transportType: config.transport.type,
+						error: mcpError.message
+					}
+				});
+				return emptyToolSet();
+			}
+			throw mcpError;
+		} finally {
+			if (connection) this.releaseConnection(connection);
+		}
+	}
+	/**
+	* Create a new pooled connection
+	*/
+	async createConnection(config, poolKey) {
+		const connectionId = `${config.name}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+		try {
+			const connection = {
+				client: await withRetryAndTimeout(async () => {
+					return createMCPClient({ transport: createTransportFromConfig(config.transport) });
+				}, config.retry ?? DEFAULT_RETRY_CONFIG, config.timeoutMs || this.poolConfig.connectionTimeoutMs, `MCP pool connection creation (${config.name})`),
+				config,
+				createdAt: /* @__PURE__ */ new Date(),
+				lastUsed: /* @__PURE__ */ new Date(),
+				inUse: true,
+				id: connectionId
+			};
+			const pool = this.connections.get(poolKey);
+			if (!pool) throw new Error(`Pool not found for key: ${poolKey}`);
+			pool.push(connection);
+			if (this.poolConfig.healthCheckEnabled) globalMCPHealthMonitor.startMonitoring(config);
+			return connection;
+		} catch (error) {
+			throw new MCPConnectionError(`Failed to create pooled MCP client '${config.name}'`, config.name, config.transport.type, error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	/**
+	* Wait for an available connection
+	*/
+	async waitForAvailableConnection(poolKey) {
+		const maxWaitTime = 3e4;
+		const checkInterval = 100;
+		const startTime = Date.now();
+		while (Date.now() - startTime < maxWaitTime) {
+			const pool = this.connections.get(poolKey);
+			if (pool) {
+				const availableConnection = pool.find((conn) => !conn.inUse);
+				if (availableConnection) {
+					availableConnection.inUse = true;
+					availableConnection.lastUsed = /* @__PURE__ */ new Date();
+					return availableConnection;
+				}
+			}
+			await new Promise((resolve) => setTimeout(resolve, checkInterval));
+		}
+		throw new Error(`Timeout waiting for available MCP connection (pool: ${poolKey})`);
+	}
+	/**
+	* Remove a connection from the pool
+	*/
+	async removeConnection(connection) {
+		const poolKey = this.getPoolKey(connection.config);
+		const pool = this.connections.get(poolKey);
+		if (pool) {
+			const index = pool.findIndex((conn) => conn.id === connection.id);
+			if (index >= 0) {
+				pool.splice(index, 1);
+				try {
+					await connection.client.close();
+				} catch (error) {
+					logWarn(`Failed to close removed pooled connection ${connection.id}`, {
+						operation: "mcp_pool_connection_close_failed",
+						metadata: {
+							connectionId: connection.id,
+							clientName: connection.config.name,
+							error: error instanceof Error ? error.message : String(error)
+						}
+					});
+				}
+			}
+		}
+	}
+	/**
+	* Generate a pool key for a client configuration
+	*/
+	getPoolKey(config) {
+		return `${config.transport.type}:${JSON.stringify(config.transport)}`;
+	}
+	/**
+	* Start periodic cleanup of idle connections
+	*/
+	startCleanupTask() {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanupIdleConnections();
+		}, 6e4);
+	}
+	/**
+	* Clean up idle connections
+	*/
+	async cleanupIdleConnections() {
+		const now = /* @__PURE__ */ new Date();
+		const idleThreshold = new Date(now.getTime() - this.poolConfig.idleTimeoutMs);
+		for (const [poolKey, pool] of this.connections.entries()) {
+			const connectionsToRemove = [];
+			for (const connection of pool) if (!connection.inUse && connection.lastUsed < idleThreshold) {
+				if (pool.length - connectionsToRemove.length > this.poolConfig.minConnections) connectionsToRemove.push(connection);
+			}
+			for (const connection of connectionsToRemove) await this.removeConnection(connection);
+			if (pool.length === 0) this.connections.delete(poolKey);
+		}
+	}
+	/**
+	* Get pool statistics
+	*/
+	getPoolStats() {
+		const stats = {};
+		for (const [poolKey, pool] of this.connections.entries()) {
+			const inUse = pool.filter((conn) => conn.inUse).length;
+			const idle = pool.filter((conn) => !conn.inUse).length;
+			stats[poolKey] = {
+				total: pool.length,
+				inUse,
+				idle
+			};
+		}
+		return stats;
+	}
+	/**
+	* Cleanup all connections and stop background tasks
+	*/
+	async cleanup() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = void 0;
+		}
+		const closePromises = [];
+		for (const pool of this.connections.values()) for (const connection of pool) closePromises.push((async () => {
+			try {
+				await connection.client.close();
+			} catch (error) {
+				logError(`Failed to close pooled connection ${connection.id}`, {
+					operation: "mcp_pool_cleanup_failed",
+					metadata: {
+						connectionId: connection.id,
+						clientName: connection.config.name
+					},
+					error: error instanceof Error ? error : new Error(String(error))
+				});
+			}
+		})());
+		await Promise.all(closePromises);
+		this.connections.clear();
+	}
+};
+function emptyToolSet() {
+	return {};
+}
+/**
+* Global MCP connection pool instance
+*/
+const globalMCPConnectionPool = new MCPConnectionPool();
+
+//#endregion
+//#region src/tools/mcp/edge-runtime.ts
+/**
+* @fileoverview edge-runtime.ts
+*/
+/**
+* Check if we're running in edge runtime
+*/
+function isEdgeRuntime() {
+	try {
+		const runtimeGlobal = globalThis;
+		return typeof process === "undefined" || process.env.VERCEL_REGION !== void 0 || typeof runtimeGlobal.WorkerGlobalScope !== "undefined" || typeof runtimeGlobal.EdgeRuntime !== "undefined";
+	} catch {
+		return true;
+	}
+}
+/**
+* Filter MCP configurations for edge runtime compatibility
+*/
+function getEdgeCompatibleConfigs(configs) {
+	return configs.filter((config) => config.transport.type !== "stdio").map((config) => ({
+		name: config.name,
+		transport: config.transport
+	}));
+}
+/**
+* Create edge-compatible MCP tools
+* This function works in both Node.js and edge runtimes
+*/
+async function createEdgeMCPTools(configs, options = {}) {
+	const clients = [];
+	const toolSets = [];
+	const timeout = options.timeout ?? 1e4;
+	const withTimeout = async (operation, label) => {
+		let timer;
+		try {
+			return await Promise.race([operation(), new Promise((_resolve, reject) => {
+				timer = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error(`${label} timed out after ${timeout}ms`));
+				}, timeout);
+			})]);
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	};
+	const clientPromises = configs.map(async (config) => {
+		try {
+			const transport = buildEdgeTransport(config.transport);
+			const { client, toolSet } = await withTimeout(async () => {
+				const clientInstance = await createMCPClient({ transport });
+				return {
+					client: clientInstance,
+					toolSet: await clientInstance.tools()
+				};
+			}, `MCP client ${config.name}`);
+			return {
+				client,
+				toolSet,
+				config
+			};
+		} catch (error) {
+			if (options.gracefulDegradation) {
+				logWarn(`Failed to create edge MCP client ${config.name}`, {
+					clientName: config.name,
+					error: error instanceof Error ? error.message : String(error),
+					operation: "mcp_edge_client_creation"
+				});
+				return null;
+			} else throw error;
+		}
+	});
+	const results = await Promise.all(clientPromises);
+	for (const result of results) if (result) {
+		clients.push(result.client);
+		toolSets.push(result.toolSet);
+	}
+	const tools = Object.assign({}, ...toolSets);
+	const closeAllClients = async () => {
+		await Promise.all(clients.map((client) => client.close().catch((error) => {
+			logWarn("Failed to close edge MCP client", {
+				error: error instanceof Error ? error.message : String(error),
+				operation: "mcp_edge_client_close"
+			});
+		})));
+	};
+	return {
+		tools,
+		clients,
+		closeAllClients
+	};
+}
+function buildEdgeTransport(transport) {
+	const url = transport.url ?? transport.httpUrl;
+	if (!url) throw new Error("HTTP URL is required for HTTP transport");
+	const headers = { ...transport.headers };
+	if (transport.type === "http" && transport.sessionId) headers["x-mcp-session-id"] = transport.sessionId;
+	return {
+		type: transport.type,
+		url,
+		headers: Object.keys(headers).length > 0 ? headers : void 0,
+		authProvider: transport.authProvider
+	};
+}
+/**
+* Pre-configured edge-compatible MCP transports
+*/
+const edgeMCPTransports = {
+	sse: (name, url, headers) => ({
+		name,
+		transport: {
+			type: "sse",
+			url,
+			headers
+		}
+	}),
+	http: (name, httpUrl, sessionId) => ({
+		name,
+		transport: {
+			type: "http",
+			url: httpUrl,
+			sessionId
+		}
+	}),
+	zapier: (apiKey) => ({
+		name: "zapier",
+		transport: {
+			type: "sse",
+			url: `https://actions.zapier.com/mcp/${apiKey}/sse`
+		}
+	}),
+	search: (baseUrl, apiKey) => ({
+		name: "search",
+		transport: {
+			type: "sse",
+			url: `${baseUrl}/mcp/sse`,
+			headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : void 0
+		}
+	})
+};
+/**
+* Environment discovery for edge runtime
+*/
+function discoverEdgeMCPServers() {
+	const servers = [];
+	if (typeof process !== "undefined" && process.env) {
+		if (process.env.ZAPIER_MCP_API_KEY) servers.push(edgeMCPTransports.zapier(process.env.ZAPIER_MCP_API_KEY));
+		const sseUrl = process.env.MCP_SSE_URL;
+		if (sseUrl) {
+			const headers = {};
+			if (process.env.MCP_SSE_API_KEY) headers["Authorization"] = `Bearer ${process.env.MCP_SSE_API_KEY}`;
+			servers.push(edgeMCPTransports.sse("custom-sse", sseUrl, headers));
+		}
+		const httpUrl = process.env.MCP_HTTP_URL;
+		if (httpUrl) servers.push(edgeMCPTransports.http("custom-http", httpUrl, process.env.MCP_HTTP_SESSION_ID));
+	}
+	return servers;
+}
+/**
+* Smart MCP client factory that chooses the right implementation based on runtime
+*/
+async function createSmartMCPTools(nodeConfigs = [], edgeConfigs = [], options = {}) {
+	const runtime = isEdgeRuntime() ? "edge" : "node";
+	if (runtime === "edge") {
+		let configs = edgeConfigs;
+		if (options.discoverFromEnvironment) {
+			const discovered = discoverEdgeMCPServers();
+			configs = [...configs, ...discovered];
+		}
+		const edgeCompatible = getEdgeCompatibleConfigs(nodeConfigs);
+		configs = [...configs, ...edgeCompatible];
+		return {
+			...await createEdgeMCPTools(configs, options),
+			runtime
+		};
+	} else {
+		const { createMCPToolsFromConfigs } = await import("./client-CpacYDIE.mjs").then((n) => n.l);
+		let configs = nodeConfigs;
+		if (options.discoverFromEnvironment) {
+			const { getMCPServers } = await import("./environment-CSoJb0SW.mjs").then((n) => n.n);
+			configs = getMCPServers(configs);
+		}
+		return {
+			...await createMCPToolsFromConfigs(configs, options),
+			runtime
+		};
+	}
+}
+
+//#endregion
+//#region src/tools/mcp/transport-selector.ts
+/**
+* Transport performance profiles
+*/
+const TRANSPORT_CHARACTERISTICS = {
+	stdio: {
+		latency: 9,
+		reliability: 8,
+		throughput: 7,
+		scalability: 4,
+		security: 7,
+		complexity: 9,
+		overhead: 9
+	},
+	sse: {
+		latency: 6,
+		reliability: 7,
+		throughput: 6,
+		scalability: 8,
+		security: 6,
+		complexity: 7,
+		overhead: 6
+	},
+	http: {
+		latency: 5,
+		reliability: 6,
+		throughput: 5,
+		scalability: 9,
+		security: 7,
+		complexity: 8,
+		overhead: 5
+	}
+};
+/**
+* Default scoring weights based on use case
+*/
+const USE_CASE_WEIGHTS = {
+	"real-time": {
+		latency: .4,
+		reliability: .2,
+		throughput: .2,
+		scalability: .1,
+		security: .05,
+		complexity: .03,
+		overhead: .02
+	},
+	"batch-processing": {
+		latency: .1,
+		reliability: .3,
+		throughput: .3,
+		scalability: .2,
+		security: .05,
+		complexity: .03,
+		overhead: .02
+	},
+	"high-availability": {
+		latency: .15,
+		reliability: .4,
+		throughput: .15,
+		scalability: .2,
+		security: .05,
+		complexity: .03,
+		overhead: .02
+	},
+	development: {
+		latency: .2,
+		reliability: .2,
+		throughput: .1,
+		scalability: .1,
+		security: .1,
+		complexity: .25,
+		overhead: .05
+	},
+	production: {
+		latency: .2,
+		reliability: .25,
+		throughput: .2,
+		scalability: .15,
+		security: .15,
+		complexity: .03,
+		overhead: .02
+	}
+};
+/**
+* MCP Transport Selector
+* Intelligently selects the best transport based on use case requirements
+*/
+var MCPTransportSelector = class {
+	/**
+	* Select optimal transport based on criteria
+	*/
+	selectTransport(criteria, availableTransports = [
+		"stdio",
+		"sse",
+		"http"
+	]) {
+		const weights = this.getWeightsForCriteria(criteria);
+		const sortedScores = this.calculateTransportScores(weights, availableTransports).sort((a, b) => b.score - a.score);
+		const best = sortedScores[0];
+		if (!best) throw new Error("No transport available");
+		const reasoningText = this.generateReasoning(criteria, best.transport);
+		const alternatives = sortedScores.slice(1).map((result) => ({
+			transport: result.transport,
+			score: result.score,
+			reason: this.getTransportReason(result.transport, criteria)
+		}));
+		return {
+			recommendedTransport: best.transport,
+			score: best.score,
+			reasoningText,
+			alternatives
+		};
+	}
+	/**
+	* Select optimal transport for common use cases
+	*/
+	selectForUseCase(useCase, availableTransports = [
+		"stdio",
+		"sse",
+		"http"
+	]) {
+		const weights = USE_CASE_WEIGHTS[useCase];
+		if (!weights) throw new Error(`Unknown use case: ${useCase}`);
+		const sortedScores = this.calculateTransportScores(weights, availableTransports).sort((a, b) => b.score - a.score);
+		const best = sortedScores[0];
+		if (!best) throw new Error("No transport available");
+		const reasoningText = [`Optimized for ${useCase} use case`];
+		const alternatives = sortedScores.slice(1).map((result) => ({
+			transport: result.transport,
+			score: result.score,
+			reason: `Alternative for ${useCase}`
+		}));
+		return {
+			recommendedTransport: best.transport,
+			score: best.score,
+			reasoningText,
+			alternatives
+		};
+	}
+	/**
+	* Get transport recommendation for specific client config
+	*/
+	recommendForClient(config) {
+		const criteria = this.inferCriteriaFromConfig(config);
+		return this.selectTransport(criteria);
+	}
+	/**
+	* Calculate weighted scores for available transports
+	*/
+	calculateTransportScores(weights, availableTransports) {
+		return availableTransports.map((transport) => {
+			const characteristics = TRANSPORT_CHARACTERISTICS[transport];
+			if (!characteristics) return {
+				transport,
+				score: 0
+			};
+			return {
+				transport,
+				score: characteristics.latency * weights.latency + characteristics.reliability * weights.reliability + characteristics.throughput * weights.throughput + characteristics.scalability * weights.scalability + characteristics.security * weights.security + (10 - characteristics.complexity) * weights.complexity + (10 - characteristics.overhead) * weights.overhead
+			};
+		});
+	}
+	/**
+	* Convert selection criteria to scoring weights
+	*/
+	getWeightsForCriteria(criteria) {
+		const weights = {
+			latency: 0,
+			reliability: 0,
+			throughput: 0,
+			scalability: 0,
+			security: 0,
+			complexity: 0,
+			overhead: 0
+		};
+		switch (criteria.latencyRequirement) {
+			case "low":
+				weights.latency = .1;
+				break;
+			case "medium":
+				weights.latency = .25;
+				break;
+			case "high":
+				weights.latency = .4;
+				break;
+		}
+		switch (criteria.reliabilityRequirement) {
+			case "basic":
+				weights.reliability = .1;
+				break;
+			case "standard":
+				weights.reliability = .25;
+				break;
+			case "high":
+				weights.reliability = .4;
+				break;
+		}
+		switch (criteria.throughputRequirement) {
+			case "low":
+				weights.throughput = .1;
+				break;
+			case "medium":
+				weights.throughput = .2;
+				break;
+			case "high":
+				weights.throughput = .3;
+				break;
+		}
+		switch (criteria.scalabilityRequirement) {
+			case "single":
+				weights.scalability = .05;
+				break;
+			case "multiple":
+				weights.scalability = .15;
+				break;
+			case "massive":
+				weights.scalability = .3;
+				break;
+		}
+		switch (criteria.securityRequirement) {
+			case "basic":
+				weights.security = .05;
+				break;
+			case "standard":
+				weights.security = .1;
+				break;
+			case "high":
+				weights.security = .2;
+				break;
+		}
+		switch (criteria.networkEnvironment) {
+			case "local":
+				weights.complexity = .15;
+				weights.overhead = .1;
+				break;
+			case "lan":
+				weights.reliability = Math.min(weights.reliability + .1, .5);
+				break;
+			case "wan":
+			case "internet":
+				weights.scalability = Math.min(weights.scalability + .1, .4);
+				weights.security = Math.min(weights.security + .1, .3);
+				break;
+		}
+		const total = Object.values(weights).reduce((sum, weight) => sum + weight, 0);
+		if (total > 0) Object.keys(weights).forEach((key) => {
+			weights[key] /= total;
+		});
+		return weights;
+	}
+	/**
+	* Generate reasoning for transport selection
+	*/
+	generateReasoning(criteria, selectedTransport) {
+		const reasoning = [];
+		const characteristics = TRANSPORT_CHARACTERISTICS[selectedTransport];
+		if (!characteristics) return reasoning;
+		if (criteria.latencyRequirement === "high" && selectedTransport === "stdio") reasoning.push("STDIO selected for lowest latency via direct IPC");
+		if (criteria.scalabilityRequirement === "massive" && selectedTransport === "http") reasoning.push("HTTP selected for maximum scalability in distributed environments");
+		if (criteria.networkEnvironment === "local" && selectedTransport === "stdio") reasoning.push("STDIO optimal for local process communication");
+		if (criteria.reliabilityRequirement === "high") reasoning.push(`Selected transport provides reliability score of ${characteristics.reliability}/10`);
+		const strengths = [];
+		if (characteristics.latency >= 8) strengths.push("excellent latency");
+		if (characteristics.reliability >= 8) strengths.push("high reliability");
+		if (characteristics.throughput >= 8) strengths.push("high throughput");
+		if (characteristics.scalability >= 8) strengths.push("excellent scalability");
+		if (characteristics.security >= 8) strengths.push("strong security");
+		if (characteristics.complexity >= 8) strengths.push("simple setup");
+		if (strengths.length > 0) reasoning.push(`Transport provides: ${strengths.join(", ")}`);
+		return reasoning.length > 0 ? reasoning : ["Selected based on overall optimization criteria"];
+	}
+	/**
+	* Get reason for alternative transport
+	*/
+	getTransportReason(transport, criteria) {
+		switch (transport) {
+			case "stdio": return "Best for low-latency local communication";
+			case "sse": return "Good balance of features with streaming support";
+			case "http": return "Best for scalable, distributed architectures";
+			default: return "Alternative transport option";
+		}
+	}
+	/**
+	* Infer selection criteria from existing client configuration
+	*/
+	inferCriteriaFromConfig(config) {
+		const criteria = {
+			latencyRequirement: "medium",
+			reliabilityRequirement: "standard",
+			throughputRequirement: "medium",
+			networkEnvironment: "local",
+			securityRequirement: "standard",
+			scalabilityRequirement: "multiple"
+		};
+		switch (config.transport.type) {
+			case "stdio":
+				criteria.networkEnvironment = "local";
+				criteria.latencyRequirement = "high";
+				criteria.scalabilityRequirement = "single";
+				break;
+			case "sse":
+				criteria.networkEnvironment = "lan";
+				criteria.throughputRequirement = "high";
+				break;
+			case "http":
+				criteria.networkEnvironment = "internet";
+				criteria.scalabilityRequirement = "massive";
+				break;
+		}
+		if (config.gracefulDegradation) criteria.reliabilityRequirement = "high";
+		if (config.timeoutMs && config.timeoutMs < 5e3) criteria.latencyRequirement = "high";
+		return criteria;
+	}
+};
+/**
+* Global transport selector instance
+*/
+const globalTransportSelector = new MCPTransportSelector();
+/**
+* Convenience function to get transport recommendation
+*/
+function selectOptimalTransport(criteria, availableTransports) {
+	return globalTransportSelector.selectTransport(criteria, availableTransports);
+}
+/**
+* Convenience function to get transport recommendation for use case
+*/
+function selectTransportForUseCase(useCase, availableTransports) {
+	return globalTransportSelector.selectForUseCase(useCase, availableTransports);
+}
+
+//#endregion
+export { testMCPConnectivity as C, createMCPStreamLifecycleManager as D, StreamLifecyclePhase as E, createMCPToolsWithStreamLifecycle as S, MCPStreamLifecycleManager as T, MCPConnectionManager as _, createEdgeMCPTools as a, createMCPToolsForStreamText as b, edgeMCPTransports as c, DEFAULT_POOL_CONFIG as d, MCPConnectionPool as f, globalMCPToolCache as g, MCPToolCache as h, selectTransportForUseCase as i, getEdgeCompatibleConfigs as l, DEFAULT_CACHE_CONFIG as m, globalTransportSelector as n, createSmartMCPTools as o, globalMCPConnectionPool as p, selectOptimalTransport as r, discoverEdgeMCPServers as s, MCPTransportSelector as t, isEdgeRuntime as u, createPooledMCPTools as v, DEFAULT_STREAM_LIFECYCLE_CONFIG as w, createMCPToolsWithDefaults as x, getGlobalConnectionManager as y };
+//# sourceMappingURL=transport-selector-D-Ib05X1.mjs.map