@mcp-use/inspector 12.0.4-canary.1 → 20.0.0-beta.0

package/dist/cdn/index-browser-CVUwR-Bu.js

@@ -0,0 +1,1934 @@
+import { i as e } from "./react-BIs9pQ3H.js";
+import { a as t, c as n, i as r, l as i, n as a, o, r as s, t as c } from "./cfWorker-Bxcs9rNe.js";
+//#region ../client/dist/index-browser.js
+var l = /* @__PURE__ */ e({
+	BaseConnector: () => q,
+	BrowserOAuthClientProvider: () => B,
+	DialectJsonSchemaValidator: () => K,
+	HttpConnector: () => Y,
+	MCPClient: () => ze,
+	MCPConnection: () => $,
+	MCPSession: () => $,
+	POSTHOG_API_KEY: () => se,
+	POSTHOG_HOST: () => oe,
+	SCARF_GATEWAY_URL: () => T,
+	Tel: () => L,
+	Telemetry: () => I,
+	VERSION: () => x,
+	capturePostHog: () => O,
+	captureScarf: () => k,
+	completeOAuthFlow: () => W,
+	createOAuthProvider: () => V,
+	getPackageVersion: () => S,
+	isUnauthorized: () => U,
+	logger: () => b,
+	normalizeClientInfo: () => Q,
+	resolveCallbacks: () => X,
+	setTelemetrySource: () => R,
+	shouldAutoProvisionOAuth: () => Z,
+	telFetch: () => w
+}), u;
+function d(e) {
+	u = e;
+}
+function f(e, t) {
+	u?.addServer(e, t);
+}
+function p(e) {
+	u?.removeServer(e);
+}
+var m;
+function h(e) {
+	m = e;
+}
+function g(e) {
+	m?.(e);
+}
+var _ = [
+	"silent",
+	"error",
+	"warn",
+	"info",
+	"http",
+	"verbose",
+	"debug",
+	"silly"
+], v = {
+	silent: "",
+	error: "❌",
+	warn: "⚠️",
+	info: "ℹ️",
+	http: "🌐",
+	verbose: "📝",
+	debug: "🔍",
+	silly: "🤪"
+};
+function y() {
+	let e;
+	try {
+		e = typeof process < "u" ? {}.MCP_USE_LOG_LEVEL ?? {}.DEBUG : void 0;
+	} catch {}
+	let t = e?.trim().toLowerCase();
+	return t === "2" ? "debug" : t && _.includes(t) ? t : "info";
+}
+var ee = class {
+	constructor(e = "mcp-use", t = "info", n = "minimal") {
+		this.name = e, this.level = t, this.format = n;
+	}
+	write(e, t, n) {
+		if (this.level === "silent" || _.indexOf(e) > _.indexOf(this.level)) return;
+		let r = n.map((e) => {
+			if (typeof e == "string") return e;
+			try {
+				return JSON.stringify(e);
+			} catch {
+				return String(e);
+			}
+		}).join(" "), i = r ? `${t} ${r}` : t, a = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: !1 }), o = this.format === "minimal" ? e : e.toUpperCase(), s = this.format === "emoji" ? ` ${v[e]}` : "", c = `${a} [${this.name}]${s} ${o}: ${i}`;
+		(e === "error" ? console.error : e === "warn" ? console.warn : e === "info" ? console.info : e === "debug" ? console.debug : console.log)(c);
+	}
+	error = (e, ...t) => this.write("error", e, t);
+	warn = (e, ...t) => this.write("warn", e, t);
+	info = (e, ...t) => this.write("info", e, t);
+	debug = (e, ...t) => this.write("debug", e, t);
+	http = (e, ...t) => this.write("http", e, t);
+	verbose = (e, ...t) => this.write("verbose", e, t);
+	silly = (e, ...t) => this.write("silly", e, t);
+	setFormat(e) {
+		this.format = e;
+	}
+}, b = class {
+	static instances = {};
+	static currentFormat = "minimal";
+	static currentLevel;
+	static get(e = "mcp-use") {
+		return this.instances[e] ??= new ee(e, this.currentLevel ?? y(), this.currentFormat);
+	}
+	static configure({ level: e = y(), format: t = "minimal" } = {}) {
+		this.currentLevel = e, this.currentFormat = t;
+		for (let n of Object.values(this.instances)) n.level = e, n.format = t;
+	}
+	static setDebug(e) {
+		let t = e === 2 || e === !0 ? "debug" : "info";
+		this.currentLevel = t;
+		for (let e of Object.values(this.instances)) e.level = t;
+		try {
+			typeof process < "u" && ({}.MCP_USE_LOG_LEVEL = t);
+		} catch {}
+	}
+	static setFormat(e) {
+		this.configure({ format: e });
+	}
+}.get(), x = "2.0.0-beta.0";
+function S() {
+	return x;
+}
+var C = class {}, te = class extends C {
+	constructor(e) {
+		super(), this.data = e;
+	}
+	get name() {
+		return "mcp_agent_execution";
+	}
+	get properties() {
+		return {
+			execution_method: this.data.executionMethod,
+			query: this.data.query,
+			query_length: this.data.query.length,
+			success: this.data.success,
+			model_provider: this.data.modelProvider,
+			model_name: this.data.modelName,
+			server_count: this.data.serverCount,
+			server_identifiers: this.data.serverIdentifiers,
+			total_tools_available: this.data.totalToolsAvailable,
+			tools_available_names: this.data.toolsAvailableNames,
+			max_steps_configured: this.data.maxStepsConfigured,
+			memory_enabled: this.data.memoryEnabled,
+			use_server_manager: this.data.useServerManager,
+			max_steps_used: this.data.maxStepsUsed,
+			manage_connector: this.data.manageConnector,
+			external_history_used: this.data.externalHistoryUsed,
+			steps_taken: this.data.stepsTaken ?? null,
+			tools_used_count: this.data.toolsUsedCount ?? null,
+			tools_used_names: this.data.toolsUsedNames ?? null,
+			response: this.data.response ?? null,
+			response_length: this.data.response ? this.data.response.length : null,
+			execution_time_ms: this.data.executionTimeMs ?? null,
+			error_type: this.data.errorType ?? null,
+			conversation_history_length: this.data.conversationHistoryLength ?? null
+		};
+	}
+}, ne = class extends C {
+	constructor(e) {
+		super(), this.data = e;
+	}
+	get name() {
+		return "mcpclient_init";
+	}
+	get properties() {
+		return {
+			code_mode: this.data.codeMode,
+			sandbox: this.data.sandbox,
+			all_callbacks: this.data.allCallbacks,
+			verify: this.data.verify,
+			servers: this.data.servers,
+			num_servers: this.data.numServers,
+			is_browser: this.data.isBrowser
+		};
+	}
+}, re = class extends C {
+	constructor(e) {
+		super(), this.data = e;
+	}
+	get name() {
+		return "connector_init";
+	}
+	get properties() {
+		return {
+			connector_type: this.data.connectorType,
+			server_command: this.data.serverCommand ?? null,
+			server_args: this.data.serverArgs ?? null,
+			server_url: this.data.serverUrl ?? null,
+			public_identifier: this.data.publicIdentifier ?? null
+		};
+	}
+}, ie = class extends C {
+	constructor(e) {
+		super(), this.data = e;
+	}
+	get name() {
+		return "client_add_server";
+	}
+	get properties() {
+		let { serverName: e, serverConfig: t } = this.data, n = t.url;
+		return {
+			server_name: e,
+			server_url_domain: n ? this._extractHostname(n) : null,
+			transport: t.transport ?? null,
+			has_auth: !!(t.authToken || t.authProvider)
+		};
+	}
+	_extractHostname(e) {
+		try {
+			return new URL(e).hostname;
+		} catch {
+			return null;
+		}
+	}
+}, ae = class extends C {
+	constructor(e) {
+		super(), this.data = e;
+	}
+	get name() {
+		return "client_remove_server";
+	}
+	get properties() {
+		return { server_name: this.data.serverName };
+	}
+};
+async function w(e, t) {
+	try {
+		await fetch(e, t);
+	} catch {}
+}
+var oe = "https://eu.i.posthog.com", se = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI", T = "https://mcpuse.gateway.scarf.sh/events-ts", E = "https://mcpuse.gateway.scarf.sh/simple/", D = 1800, ce = /* @__PURE__ */ new Set([
+	"query",
+	"response",
+	"messages"
+]);
+function le(e) {
+	if (e == null) return "";
+	if (typeof e == "string") return e;
+	if (typeof e == "number" || typeof e == "boolean") return String(e);
+	try {
+		return JSON.stringify(e);
+	} catch {
+		return String(e);
+	}
+}
+function ue(e, t = E) {
+	let n = new URLSearchParams();
+	for (let [t, r] of Object.entries(e)) {
+		let e = le(r);
+		ce.has(t) && e.length > 120 && (e = `${e.slice(0, 117)}...`), e !== "" && n.set(t, e);
+	}
+	let r = `${t}${t.includes("?") ? "&" : "?"}${n.toString()}`;
+	if (r.length <= D) return r;
+	let i = [...n.keys()].sort((e, t) => (n.get(t)?.length ?? 0) - (n.get(e)?.length ?? 0));
+	for (let e of i) {
+		if (r.length <= D) break;
+		e === "event" || e === "user_id" || (n.delete(e), r = `${t}${t.includes("?") ? "&" : "?"}${n.toString()}`);
+	}
+	return r.slice(0, D);
+}
+function de(e, t) {
+	return w(t, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		keepalive: !0,
+		body: JSON.stringify(e)
+	});
+}
+function fe(e, t) {
+	try {
+		let n = ue(e, t), r = new Image();
+		r.referrerPolicy = "no-referrer-when-downgrade", r.src = n;
+	} catch {}
+	return Promise.resolve();
+}
+function O(e) {
+	let t = e.host ?? "https://eu.i.posthog.com", n = e.apiKey ?? "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
+	return w(`${t}/i/v0/e/`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		keepalive: !0,
+		body: JSON.stringify({
+			api_key: n,
+			event: e.event,
+			distinct_id: e.distinctId,
+			properties: e.properties,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		})
+	});
+}
+function k(e, t = T) {
+	return typeof window < "u" ? fe(e, t === "https://mcpuse.gateway.scarf.sh/events-ts" ? E : t) : de(e, t);
+}
+function A() {
+	return globalThis.crypto.randomUUID();
+}
+function pe() {
+	let e = new Uint8Array(8);
+	return globalThis.crypto.getRandomValues(e), Array.from(e, (e) => e.toString(16).padStart(2, "0")).join("");
+}
+function me(e, t) {
+	let n = (e) => e.split("-")[0].split(".").map((e) => parseInt(e, 10) || 0), r = n(e), i = n(t), a = Math.max(r.length, i.length);
+	for (let e = 0; e < a; e++) {
+		let t = r[e] ?? 0, n = i[e] ?? 0;
+		if (t !== n) return t > n;
+	}
+	return !1;
+}
+var j = "mcp_use_user_id", M = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI", N = "https://eu.i.posthog.com", P = null;
+function F() {
+	return typeof localStorage < "u" && typeof localStorage.getItem == "function" && typeof localStorage.setItem == "function" && typeof localStorage.removeItem == "function";
+}
+function he() {
+	if (!F()) return null;
+	try {
+		localStorage.setItem("__mcp_use_test__", "1"), localStorage.removeItem("__mcp_use_test__");
+	} catch {
+		return null;
+	}
+	return {
+		getUserId() {
+			try {
+				return localStorage.getItem(j);
+			} catch {
+				return null;
+			}
+		},
+		setUserId(e) {
+			try {
+				localStorage.setItem(j, e);
+			} catch {}
+		},
+		getDownloadedVersion: () => null,
+		setDownloadedVersion: () => void 0
+	};
+}
+function ge() {
+	try {
+		return globalThis.Bun === void 0 ? globalThis.Deno === void 0 ? typeof navigator < "u" && navigator.userAgent?.includes("Cloudflare-Workers") ? "cloudflare-workers" : globalThis.EdgeRuntime === void 0 ? typeof window < "u" && typeof document < "u" ? "browser" : typeof process < "u" && process.versions?.node !== void 0 ? "node" : "unknown" : "edge" : "deno" : "bun";
+	} catch {
+		return "unknown";
+	}
+}
+function _e() {
+	if (typeof process < "u" && {}.MCP_USE_TELEMETRY_SOURCE) return {}.MCP_USE_TELEMETRY_SOURCE;
+	try {
+		if (F()) return localStorage.getItem("MCP_USE_TELEMETRY_SOURCE") ?? void 0;
+	} catch {}
+}
+function ve() {
+	if (typeof window < "u" && window.__MCP_USE_ANONYMIZED_TELEMETRY__ === !1 || typeof process < "u" && {}.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false") return !0;
+	try {
+		if (F() && localStorage.getItem("MCP_USE_ANONYMIZED_TELEMETRY") === "false") return !0;
+	} catch {}
+	return !1;
+}
+function ye() {
+	try {
+		return `session-${A()}`;
+	} catch {
+		return `session-${Date.now()}-${pe()}`;
+	}
+}
+var I = class e {
+	static instance = null;
+	UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
+	_currUserId = null;
+	_telemetryEnabled = !1;
+	_pending = /* @__PURE__ */ new Set();
+	_scarfEnabled = !1;
+	_runtimeEnvironment;
+	_storageCapability;
+	_storage;
+	_fsBacked;
+	_source;
+	_productVersion;
+	constructor() {
+		this._runtimeEnvironment = ge(), this._fsBacked = P !== null, this._storage = P ?? he() ?? null, this._storageCapability = this._storage ? "persistent" : "session-only", this._source = _e() || this._runtimeEnvironment;
+		let e = ve(), t = this._runtimeEnvironment !== "unknown";
+		e ? (this._telemetryEnabled = !1, b.debug("Telemetry disabled via opt-out")) : t ? (b.debug("Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."), this._telemetryEnabled = !0, this._scarfEnabled = !0, this._fsBacked && setTimeout(() => {
+			this.trackPackageDownload({ triggered_by: "initialization" }).catch((e) => b.debug(`Failed to track package download: ${e}`));
+		}, 0)) : (this._telemetryEnabled = !1, b.debug(`Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`));
+	}
+	get runtimeEnvironment() {
+		return this._runtimeEnvironment;
+	}
+	get storageCapability() {
+		return this._storageCapability;
+	}
+	static getInstance() {
+		return e.instance ||= new e(), e.instance;
+	}
+	setSource(e) {
+		this._source = e;
+		try {
+			F() && localStorage.setItem("MCP_USE_TELEMETRY_SOURCE", e);
+		} catch {}
+		b.debug(`Telemetry source set to: ${e}`);
+	}
+	getSource() {
+		return this._source;
+	}
+	setProductVersion(e) {
+		this._productVersion = e;
+	}
+	get isEnabled() {
+		return this._telemetryEnabled || this._scarfEnabled;
+	}
+	get userId() {
+		if (this._currUserId) return this._currUserId;
+		try {
+			if (this._storage) {
+				let e = this._storage.getUserId();
+				if (e) return this._currUserId = e, e;
+				let t = A();
+				return this._storage.setUserId(t), this._currUserId = t, t;
+			}
+			this._currUserId = ye();
+		} catch {
+			this._currUserId = this.UNKNOWN_USER_ID;
+		}
+		return this._currUserId;
+	}
+	async capture(e) {
+		if (!this._telemetryEnabled && !this._scarfEnabled) return;
+		let t = this.userId, n = {
+			...e.properties,
+			mcp_use_version: this._productVersion ?? S(),
+			language: "typescript",
+			source: this._source,
+			runtime: this._runtimeEnvironment
+		};
+		if (this._telemetryEnabled) {
+			let r = O({
+				host: N,
+				apiKey: M,
+				event: e.name,
+				distinctId: t,
+				properties: n
+			});
+			this._pending.add(r), r.finally(() => this._pending.delete(r));
+		}
+		if (this._scarfEnabled) {
+			let r = k({
+				...n,
+				user_id: t,
+				event: e.name
+			});
+			this._pending.add(r), r.finally(() => this._pending.delete(r));
+		}
+	}
+	async trackPackageDownload(e) {
+		if (!this._scarfEnabled || !this._fsBacked || !this._storage) return;
+		let t = S(), n = this._storage.getDownloadedVersion(), r = !1, i = !1;
+		n ? me(t, n) && (i = !0, this._storage.setDownloadedVersion(t)) : (i = !0, r = !0, this._storage.setDownloadedVersion(t)), i && await k({
+			...e || {},
+			mcp_use_version: t,
+			user_id: this.userId,
+			event: "package_download",
+			first_download: r,
+			language: "typescript",
+			source: this._source,
+			runtime: this._runtimeEnvironment
+		});
+	}
+	async trackAgentExecution(e) {
+		this.isEnabled && await this.capture(new te(e));
+	}
+	async trackMCPClientInit(e) {
+		this.isEnabled && await this.capture(new ne(e));
+	}
+	async trackConnectorInit(e) {
+		this.isEnabled && await this.capture(new re(e));
+	}
+	async trackClientAddServer(e, t) {
+		this.isEnabled && await this.capture(new ie({
+			serverName: e,
+			serverConfig: t
+		}));
+	}
+	async trackClientRemoveServer(e) {
+		this.isEnabled && await this.capture(new ae({ serverName: e }));
+	}
+	async trackUseMcpConnection(e) {
+		this.isEnabled && await this.capture({
+			name: "usemcp_connection",
+			properties: {
+				url_domain: new URL(e.url).hostname,
+				transport_type: e.transportType,
+				success: e.success,
+				error_type: e.errorType ?? null,
+				connection_time_ms: e.connectionTimeMs ?? null,
+				has_oauth: e.hasOAuth,
+				has_sampling: e.hasSampling,
+				has_elicitation: e.hasElicitation
+			}
+		});
+	}
+	async trackUseMcpToolCall(e) {
+		this.isEnabled && await this.capture({
+			name: "usemcp_tool_call",
+			properties: {
+				tool_name: e.toolName,
+				success: e.success,
+				error_type: e.errorType ?? null,
+				execution_time_ms: e.executionTimeMs ?? null
+			}
+		});
+	}
+	async trackUseMcpResourceRead(e) {
+		this.isEnabled && await this.capture({
+			name: "usemcp_resource_read",
+			properties: {
+				resource_uri_scheme: e.resourceUri.split(":")[0],
+				success: e.success,
+				error_type: e.errorType ?? null
+			}
+		});
+	}
+	identify(e, t) {
+		this._currUserId = e, this._storage?.setUserId(e), this._telemetryEnabled && O({
+			host: N,
+			apiKey: M,
+			event: "$identify",
+			distinctId: e,
+			properties: { $set: t ?? {} }
+		});
+	}
+	reset() {
+		this._currUserId = null;
+	}
+	flush() {
+		Promise.allSettled([...this._pending]);
+	}
+	async shutdown() {
+		try {
+			await Promise.allSettled([...this._pending]), b.debug("Telemetry fetch captures flushed");
+		} catch (e) {
+			b.debug(`Error flushing telemetry captures: ${e}`);
+		}
+	}
+}, L = I;
+function R(e) {
+	L.getInstance().setSource(e);
+}
+d({
+	addServer: (e, t) => I.getInstance().trackClientAddServer(e, t).catch(() => void 0),
+	removeServer: (e) => I.getInstance().trackClientRemoveServer(e).catch(() => void 0)
+}), h((e) => I.getInstance().trackConnectorInit(e).catch(() => void 0));
+function z(e) {
+	let t = () => {
+		throw Error(`Invalid url to pass to open(): ${e}`);
+	}, n;
+	try {
+		n = new URL(e);
+	} catch {
+		t();
+	}
+	return n.protocol !== "https:" && n.protocol !== "http:" && t(), n.hostname !== encodeURIComponent(n.hostname) && t(), n.username &&= encodeURIComponent(n.username), n.password &&= encodeURIComponent(n.password), n.pathname = n.pathname.slice(0, 1) + encodeURIComponent(n.pathname.slice(1)).replace(/%2f/gi, "/"), n.search = n.search.slice(0, 1) + Array.from(n.searchParams.entries()).map(be).join("&"), n.hash = n.hash.slice(0, 1) + encodeURIComponent(n.hash.slice(1)), n.href;
+}
+function be([e, t]) {
+	return `${encodeURIComponent(e)}${t.length > 0 ? `=${encodeURIComponent(t)}` : ""}`;
+}
+var xe = class {
+	get(e) {
+		return localStorage.getItem(e);
+	}
+	set(e, t) {
+		localStorage.setItem(e, t);
+	}
+	remove(e) {
+		localStorage.removeItem(e);
+	}
+	keys() {
+		let e = [];
+		for (let t = 0; t < localStorage.length; t++) {
+			let n = localStorage.key(t);
+			n && e.push(n);
+		}
+		return e;
+	}
+}, Se = class e {
+	serverUrl;
+	storageKeyPrefix;
+	serverUrlHash;
+	clientName;
+	clientUri;
+	logoUri;
+	callbackUrl;
+	clientMetadataUrl;
+	scope;
+	store;
+	allowClientSecret;
+	constructor(n, r, i) {
+		t(r.clientMetadataUrl), this.serverUrl = n, this.storageKeyPrefix = r.storageKeyPrefix || "mcp:auth", this.serverUrlHash = e.hashString(n), this.clientName = r.clientName || "mcp-use", this.clientUri = r.clientUri || (typeof window < "u" ? window.location.origin : "https://mcp-use.com"), this.logoUri = r.logoUri || "https://mcp-use.com/logo.png", this.callbackUrl = z(r.callbackUrl || (typeof window < "u" ? new URL("/oauth/callback", window.location.origin).toString() : "/oauth/callback")), this.clientMetadataUrl = r.clientMetadataUrl, this.scope = r.scope, this.store = i, this.allowClientSecret = r.allowClientSecret ?? !0;
+	}
+	getKey(e) {
+		return `${this.storageKeyPrefix}_${this.serverUrlHash}_${e}`;
+	}
+	static hashString(e) {
+		let t = 0;
+		for (let n = 0; n < e.length; n++) {
+			let r = e.charCodeAt(n);
+			t = (t << 5) - t + r, t &= t;
+		}
+		return Math.abs(t).toString(16);
+	}
+	get redirectUrl() {
+		return this.callbackUrl;
+	}
+	get clientMetadata() {
+		return {
+			redirect_uris: [this.redirectUrl],
+			token_endpoint_auth_method: "none",
+			grant_types: ["authorization_code", "refresh_token"],
+			response_types: ["code"],
+			client_name: this.clientName,
+			client_uri: this.clientUri,
+			logo_uri: this.logoUri,
+			...this.scope ? { scope: this.scope } : {}
+		};
+	}
+	credentialKey(e, t) {
+		return t ? this.getKey(`${e}_${encodeURIComponent(t.issuer)}`) : this.getKey(e);
+	}
+	async readCredential(e, t) {
+		let n = this.credentialKey(e, t), r = await this.store.get(n);
+		if (!r && t) {
+			let r = this.credentialKey(e), i = await this.store.get(r);
+			if (i) try {
+				let e = JSON.parse(i);
+				if (!e.issuer || e.issuer === t.issuer) {
+					let i = {
+						...e,
+						issuer: t.issuer
+					}, a = JSON.stringify(i);
+					return await this.store.set(n, a), await this.store.set(r, a), {
+						key: n,
+						value: i
+					};
+				}
+			} catch {
+				await this.store.remove(r);
+			}
+			return;
+		}
+		if (r) try {
+			return {
+				key: n,
+				value: JSON.parse(r)
+			};
+		} catch (t) {
+			console.warn(`[${this.storageKeyPrefix}] Failed to parse ${e.replace("_", " ")}:`, t), await this.store.remove(n);
+			return;
+		}
+	}
+	async tokens(e) {
+		return (await this.readCredential("tokens", e))?.value;
+	}
+	async saveTokens(e, t) {
+		let n = JSON.stringify(e);
+		await this.store.set(this.credentialKey("tokens", t), n), t && await this.store.set(this.credentialKey("tokens"), n), await this.store.remove(this.getKey("code_verifier")), await this.store.remove(this.getKey("last_auth_url"));
+	}
+	async clientInformation(e) {
+		let t = await this.readCredential("client_info", e);
+		if (!t) return;
+		let { key: n, value: r } = t;
+		try {
+			if (!this.allowClientSecret && r.client_secret) {
+				await this.store.remove(n), e && await this.store.remove(this.credentialKey("client_info")), console.warn(`[${this.storageKeyPrefix}] Removed OAuth client information containing a browser client_secret.`);
+				return;
+			}
+			let t = Array.isArray(r.redirect_uris) ? r.redirect_uris : [];
+			if (!(t.length === 0 || t.includes(this.redirectUrl))) {
+				console.info(`[${this.storageKeyPrefix}] Invalidating cached OAuth client info due to redirect URI mismatch.`), await this.store.remove(n), await this.store.remove(this.credentialKey("tokens", e)), await this.store.remove(this.getKey("last_auth_url"));
+				return;
+			}
+			return r;
+		} catch {
+			await this.store.remove(n);
+			return;
+		}
+	}
+	async saveClientInformation(e, t) {
+		let n = e;
+		if (!this.allowClientSecret && n.client_secret) throw await this.store.remove(this.credentialKey("client_info", t)), t && await this.store.remove(this.credentialKey("client_info")), Error("Browser OAuth clients must be public clients; client_secret persistence is not allowed.");
+		let r = JSON.stringify(e);
+		await this.store.set(this.credentialKey("client_info", t), r), t && await this.store.set(this.credentialKey("client_info"), r);
+	}
+	async saveCodeVerifier(e) {
+		await this.store.set(this.getKey("code_verifier"), e);
+	}
+	async codeVerifier() {
+		let e = this.getKey("code_verifier"), t = await this.store.get(e);
+		if (!t) throw Error(`[${this.storageKeyPrefix}] Code verifier not found in storage for key ${e}. Auth flow likely corrupted or timed out.`);
+		return t;
+	}
+	async invalidateCredentials(e) {
+		let t = async (e) => {
+			let t = `${this.getKey(e)}_`;
+			for (let n of await this.store.keys()) (n === this.getKey(e) || n.startsWith(t)) && await this.store.remove(n);
+		};
+		switch (e) {
+			case "all":
+				await t("tokens"), await t("client_info"), await this.store.remove(this.getKey("code_verifier")), await this.store.remove(this.getKey("last_auth_url")), await this.store.remove(this.getKey("discovery_state")), await this.store.remove(this.getKey("token_endpoint"));
+				break;
+			case "client":
+				await t("client_info");
+				break;
+			case "tokens":
+				await t("tokens");
+				break;
+			case "verifier":
+				await this.store.remove(this.getKey("code_verifier"));
+				break;
+			case "discovery":
+				await this.store.remove(this.getKey("discovery_state"));
+				break;
+			default: break;
+		}
+	}
+	async saveDiscoveryState(e) {
+		await this.store.set(this.getKey("discovery_state"), JSON.stringify(e));
+	}
+	async discoveryState() {
+		let e = await this.store.get(this.getKey("discovery_state"));
+		if (e) try {
+			return JSON.parse(e);
+		} catch {
+			await this.store.remove(this.getKey("discovery_state"));
+			return;
+		}
+	}
+	async storeAuthorizationState(e, t = {}) {
+		let n = globalThis.crypto.randomUUID(), r = `${this.storageKeyPrefix}:state_${n}`, i = {
+			serverUrlHash: this.serverUrlHash,
+			expiry: Date.now() + 1e3 * 60 * 10,
+			providerOptions: {
+				serverUrl: this.serverUrl,
+				storageKeyPrefix: this.storageKeyPrefix,
+				clientName: this.clientName,
+				clientUri: this.clientUri,
+				callbackUrl: this.callbackUrl,
+				...this.clientMetadataUrl ? { clientMetadataUrl: this.clientMetadataUrl } : {},
+				...t.extraProviderOptions ?? {}
+			},
+			flowType: t.flowType,
+			returnUrl: t.returnUrl
+		};
+		e.searchParams.set("state", n);
+		let a = z(e.toString());
+		return await this.store.set(r, JSON.stringify(i)), await this.store.set(this.getKey("last_auth_url"), a), a;
+	}
+	async getTokenEndpoint() {
+		return (await this.discoveryState())?.authorizationServerMetadata?.token_endpoint ?? null;
+	}
+};
+async function Ce(e) {
+	return typeof e == "string" ? e : e instanceof URLSearchParams || e instanceof FormData ? Object.fromEntries(e.entries()) : e instanceof Blob ? await e.text() : e;
+}
+var B = class {
+	serverUrl;
+	staticClientInfo;
+	session;
+	preventAutoAuth;
+	useRedirectFlow;
+	oauthProxyUrl;
+	connectionUrl;
+	proxyOAuthRequests;
+	onPopupWindow;
+	constructor(e, t = {}) {
+		if (t.staticClientInfo?.client_secret) throw Error("Browser OAuth clients must be public clients; staticClientInfo.client_secret is not allowed.");
+		this.serverUrl = e, this.session = new Se(e, {
+			...t,
+			allowClientSecret: !1
+		}, new xe()), this.preventAutoAuth = t.preventAutoAuth, this.useRedirectFlow = t.useRedirectFlow, this.oauthProxyUrl = t.oauthProxyUrl, this.connectionUrl = t.connectionUrl, this.proxyOAuthRequests = t.proxyOAuthRequests ?? !0, this.staticClientInfo = t.staticClientInfo, this.onPopupWindow = t.onPopupWindow;
+	}
+	get storageKeyPrefix() {
+		return this.session.storageKeyPrefix;
+	}
+	get serverUrlHash() {
+		return this.session.serverUrlHash;
+	}
+	get clientName() {
+		return this.session.clientName;
+	}
+	get clientUri() {
+		return this.session.clientUri;
+	}
+	get logoUri() {
+		return this.session.logoUri;
+	}
+	get callbackUrl() {
+		return this.session.callbackUrl;
+	}
+	get scope() {
+		return this.session.scope;
+	}
+	get clientMetadataUrl() {
+		return this.session.clientMetadataUrl;
+	}
+	getKey(e) {
+		return this.session.getKey(e);
+	}
+	reanchorWellKnownUrl(e) {
+		if (!this.connectionUrl) return e;
+		try {
+			let t = new URL(e), n = new URL(this.connectionUrl);
+			if (t.origin !== n.origin || !t.pathname.startsWith("/.well-known/")) return e;
+			let r = new URL(this.serverUrl), [i, ...a] = t.pathname.slice(13).split("/");
+			if (!i) return e;
+			let o = a.length ? `/${a.join("/")}` : "", s = n.pathname.replace(/\/+$/, ""), c = r.pathname.replace(/\/+$/, ""), l = o && o === s ? c : o;
+			return `${r.origin}/.well-known/${i}${l}${t.search}`;
+		} catch {
+			return e;
+		}
+	}
+	getProxyFetch(e) {
+		if (!this.proxyOAuthRequests || !this.oauthProxyUrl) return e;
+		let t = e ?? globalThis.fetch.bind(globalThis), n = this.oauthProxyUrl, r = /* @__PURE__ */ new Set(), i = !1;
+		return async (e, a) => {
+			let o = typeof e == "string" ? e : e instanceof URL ? e.toString() : e.url, s = this.reanchorWellKnownUrl(o), c;
+			try {
+				c = new URL(s).pathname;
+			} catch {
+				return await t(e, a);
+			}
+			let l = c.includes("/.well-known/");
+			if (!i) {
+				i = !0;
+				let e = (await this.discoveryState())?.authorizationServerMetadata;
+				for (let t of [
+					"registration_endpoint",
+					"token_endpoint",
+					"revocation_endpoint",
+					"introspection_endpoint"
+				]) typeof e?.[t] == "string" && r.add(e[t]);
+			}
+			let u = r.has(s) || /\/(?:register|registration|token|revoke|revocation|introspect|introspection)\/?$/.test(c);
+			if (!l && !u) return await t(e, a);
+			try {
+				let r = new URL(s), i = new URL(n);
+				if (r.origin === i.origin && (r.pathname.startsWith(i.pathname) || s.includes("/inspector/api/oauth"))) return await t(e, a);
+			} catch {}
+			let d = l ? `${n}/metadata?serverUrl=${encodeURIComponent(this.serverUrl)}&url=${encodeURIComponent(s)}` : `${n}/proxy`;
+			if (l) {
+				let e = await t(d, {
+					...a,
+					method: "GET"
+				});
+				try {
+					let t = await e.clone().json();
+					for (let e of [
+						"registration_endpoint",
+						"token_endpoint",
+						"revocation_endpoint",
+						"introspection_endpoint"
+					]) typeof t[e] == "string" && r.add(t[e]);
+				} catch {}
+				return e;
+			}
+			let f = a?.body ? await Ce(a.body) : void 0, p = await (await t(d, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					serverUrl: this.serverUrl,
+					url: s,
+					method: a?.method || "POST",
+					headers: a?.headers ? Object.fromEntries(new Headers(a.headers)) : {},
+					body: f
+				})
+			})).json();
+			return new Response(JSON.stringify(p.body), {
+				status: p.status,
+				statusText: p.statusText,
+				headers: new Headers(p.headers)
+			});
+		};
+	}
+	get redirectUrl() {
+		return this.session.redirectUrl;
+	}
+	get clientMetadata() {
+		return this.session.clientMetadata;
+	}
+	tokens(e) {
+		return this.session.tokens(e);
+	}
+	saveTokens(e, t) {
+		return this.session.saveTokens(e, t);
+	}
+	async clientInformation(e) {
+		return this.staticClientInfo ? this.staticClientInfo : this.session.clientInformation(e);
+	}
+	async saveClientInformation(e, t) {
+		if (!this.staticClientInfo) return this.session.saveClientInformation(e, t);
+	}
+	codeVerifier() {
+		return this.session.codeVerifier();
+	}
+	saveCodeVerifier(e) {
+		return this.session.saveCodeVerifier(e);
+	}
+	invalidateCredentials(e) {
+		return this.session.invalidateCredentials(e);
+	}
+	saveDiscoveryState(e) {
+		return this.session.saveDiscoveryState(e);
+	}
+	discoveryState() {
+		return this.session.discoveryState();
+	}
+	getTokenEndpoint() {
+		return this.session.getTokenEndpoint();
+	}
+	async getClientCredentials() {
+		let e = await this.clientInformation();
+		return e?.client_id ? { client_id: e.client_id } : null;
+	}
+	async prepareAuthorizationUrl(e) {
+		return this.session.storeAuthorizationState(e, {
+			extraProviderOptions: {
+				oauthProxyUrl: this.oauthProxyUrl,
+				...this.clientMetadataUrl ? { clientMetadataUrl: this.clientMetadataUrl } : {},
+				...this.staticClientInfo ? { staticClientInfo: this.staticClientInfo } : {},
+				...this.scope ? { scope: this.scope } : {}
+			},
+			flowType: this.useRedirectFlow ? "redirect" : "popup",
+			returnUrl: typeof window < "u" ? window.location.href : void 0
+		});
+	}
+	async redirectToAuthorization(e) {
+		let t = await this.prepareAuthorizationUrl(e);
+		if (this.preventAutoAuth) {
+			console.info(`[${this.storageKeyPrefix}] Auto-auth prevented. Authorization URL stored for manual trigger.`);
+			return;
+		}
+		if (this.useRedirectFlow) {
+			console.info(`[${this.storageKeyPrefix}] Redirecting to authorization URL (full-page redirect).`), window.location.href = t;
+			return;
+		}
+		let n = "width=600,height=700,resizable=yes,scrollbars=yes,status=yes";
+		try {
+			let e = window.open(t, `mcp_auth_${this.serverUrlHash}`, n);
+			this.onPopupWindow && this.onPopupWindow(t, n, e), !e || e.closed || e.closed === void 0 ? console.warn(`[${this.storageKeyPrefix}] Popup likely blocked by browser. Manual navigation might be required using the stored URL.`) : (e.focus(), console.info(`[${this.storageKeyPrefix}] Redirecting to authorization URL in popup.`));
+		} catch (e) {
+			console.error(`[${this.storageKeyPrefix}] Error opening popup window:`, e);
+		}
+	}
+	getLastAttemptedAuthUrl() {
+		let e = localStorage.getItem(this.getKey("last_auth_url"));
+		return e ? z(e) : null;
+	}
+	clearStorage() {
+		let e = `${this.storageKeyPrefix}_${this.serverUrlHash}_`, t = `${this.storageKeyPrefix}:state_`, n = [], r = 0;
+		for (let r = 0; r < localStorage.length; r++) {
+			let i = localStorage.key(r);
+			if (i) {
+				if (i.startsWith(e)) n.push(i);
+				else if (i.startsWith(t)) try {
+					let e = localStorage.getItem(i);
+					e && JSON.parse(e).serverUrlHash === this.serverUrlHash && n.push(i);
+				} catch (e) {
+					console.warn(`[${this.storageKeyPrefix}] Error parsing state key ${i} during clearStorage:`, e);
+				}
+			}
+		}
+		return [...new Set(n)].forEach((e) => {
+			localStorage.removeItem(e), r++;
+		}), r;
+	}
+};
+async function V(e, t = {}) {
+	return new B(e, t);
+}
+var we = "mcp_auth_callback", Te = "mcp_auth_callback";
+function H(e) {
+	try {
+		return typeof localStorage < "u" && !!localStorage.getItem(e);
+	} catch {
+		return !1;
+	}
+}
+function Ee({ popup: e, state: t, tokensKey: n, timeoutMs: r = 5 * 6e4, closePollMs: i = 1e3, closeGraceMs: a = 2e4, expectedOrigin: o = typeof window < "u" ? window.location.origin : "" }) {
+	return new Promise((s) => {
+		let c = !1, l = null, u = null, d = null, f = null, p = () => {
+			if (l &&= (clearInterval(l), null), u &&= (clearTimeout(u), null), d &&= (clearTimeout(d), null), typeof window < "u" && (window.removeEventListener("message", g), window.removeEventListener("storage", v)), f) {
+				try {
+					f.removeEventListener("message", _), f.close();
+				} catch {}
+				f = null;
+			}
+		}, m = (e) => {
+			c || (c = !0, p(), s(e));
+		}, h = (e) => {
+			!e || e.type !== Te || e.state && t && e.state !== t || (e.success ? m({ kind: "success" }) : m({
+				kind: "error",
+				error: e.error ?? "Authentication failed in callback."
+			}));
+		}, g = (e) => {
+			o && e.origin !== o || h(e.data);
+		}, _ = (e) => {
+			h(e.data);
+		}, v = (e) => {
+			e.key === n && e.newValue && m({ kind: "success" });
+		};
+		if (typeof window < "u" && (window.addEventListener("message", g), window.addEventListener("storage", v)), typeof BroadcastChannel < "u") try {
+			f = new BroadcastChannel(we), f.addEventListener("message", _);
+		} catch {
+			f = null;
+		}
+		e && (l = setInterval(() => {
+			if (c) return;
+			let t = !1;
+			try {
+				t = e.closed;
+			} catch {
+				t = !1;
+			}
+			if (t) {
+				if (l &&= (clearInterval(l), null), H(n)) {
+					m({ kind: "success" });
+					return;
+				}
+				d = setTimeout(() => {
+					m(H(n) ? { kind: "success" } : { kind: "cancelled" });
+				}, a);
+			}
+		}, i)), u = setTimeout(() => {
+			m(H(n) ? { kind: "success" } : { kind: "timeout" });
+		}, r);
+	});
+}
+var De = 5 * 6e4;
+function U(e, t = 0) {
+	if (!e || t > 5) return !1;
+	if (e instanceof s) return !0;
+	if (e instanceof Error) {
+		if (e.code === 401 || e.name === "UnauthorizedError") return !0;
+		let n = e.message ?? "";
+		if (n.includes("401") || n.includes("Unauthorized") || e.cause && U(e.cause, t + 1)) return !0;
+		let r = e.data;
+		if (r?.cause && U(r.cause, t + 1)) return !0;
+	}
+	return !1;
+}
+async function W(e, t, n = {}) {
+	let i = e, a = n.timeoutMs ?? De, o = n.fetchFn ?? i.getProxyFetch?.() ?? void 0;
+	if (!i.hasPendingFlow) {
+		let n = await r(e, {
+			serverUrl: t,
+			fetchFn: o
+		});
+		if (n === "AUTHORIZED") return;
+		if (n !== "REDIRECT") throw Error(`Unexpected OAuth auth() result: ${n}`);
+	}
+	if (typeof i.getAuthorizationCode == "function") {
+		await r(e, {
+			serverUrl: t,
+			authorizationCode: await i.getAuthorizationCode(),
+			fetchFn: o
+		});
+		return;
+	}
+	await G(i, a);
+}
+async function G(e, t) {
+	if (typeof window > "u") throw Error("OAuth redirect requires a browser environment or a provider with getAuthorizationCode()");
+	if (e.useRedirectFlow) return;
+	let n = e.getKey?.("tokens");
+	if (!n) throw Error("Browser OAuth provider must expose getKey() for token storage");
+	let r = null, i = e.getLastAttemptedAuthUrl?.();
+	if (i) try {
+		r = new URL(i).searchParams.get("state");
+	} catch {}
+	let a = await Ee({
+		popup: null,
+		state: r,
+		tokensKey: n,
+		timeoutMs: t
+	});
+	switch (a.kind) {
+		case "success": return;
+		case "cancelled": throw Error("OAuth authentication was cancelled.");
+		case "timeout": throw Error(`OAuth callback not received within ${t}ms. Ensure /oauth/callback calls onMcpAuthorization().`);
+		case "error": throw Error(a.error);
+		default: throw Error("Unexpected OAuth popup result");
+	}
+}
+var Oe = "http://json-schema.org/draft-04/schema", ke = /* @__PURE__ */ new Set(["http://json-schema.org/draft-07/schema", "https://json-schema.org/draft-07/schema"]), Ae = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2019-09/schema", "http://json-schema.org/draft/2019-09/schema"]), je = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
+function Me(e) {
+	if (!("$schema" in e) || typeof e.$schema != "string") return "2020-12";
+	let t = e.$schema.replace(/#$/, "");
+	if (t === Oe) return "4";
+	if (ke.has(t)) return "7";
+	if (Ae.has(t)) return "2019-09";
+	if (je.has(t)) return "2020-12";
+}
+var K = class {
+	getValidator(e) {
+		let t = Me(e);
+		return (t === void 0 ? new o() : new o({ draft: t })).getValidator(e);
+	}
+}, Ne = { "~standard": {
+	version: 1,
+	vendor: "mcp-use",
+	validate: (e) => ({ value: e })
+} }, q = class {
+	client = null;
+	connectionManager = null;
+	toolsCache = null;
+	capabilitiesCache = null;
+	serverInfoCache = null;
+	connected = !1;
+	opts;
+	notificationHandlers = [];
+	rootsCache = [];
+	activeProgressHandlers = /* @__PURE__ */ new Set();
+	constructor(e = {}) {
+		this.opts = e, e.roots && (this.rootsCache = [...e.roots]), e.onNotification && this.notificationHandlers.push(e.onNotification);
+	}
+	trackConnectorInit(e) {
+		let t = this.constructor.name;
+		g({
+			connectorType: t,
+			...e
+		});
+	}
+	onNotification(e) {
+		this.notificationHandlers.push(e), this.client && this.setupNotificationHandler();
+	}
+	async forwardNotification(e) {
+		for (let t of this.notificationHandlers) try {
+			await t(e);
+		} catch (e) {
+			b.error("Error in notification handler:", e);
+		}
+	}
+	async handleListChanged(e, t, n) {
+		if (t) {
+			b.warn(`[Auto] ${e} refresh failed:`, t);
+			return;
+		}
+		e === "notifications/tools/list_changed" && n && (this.toolsCache = [...n]), await this.forwardNotification({ method: e });
+	}
+	setupNotificationHandler() {
+		if (!this.client) return;
+		this.client.fallbackNotificationHandler = async (e) => {
+			switch (e.method) {
+				case "notifications/tools/list_changed":
+					await this.refreshToolsCache();
+					break;
+				case "notifications/resources/list_changed":
+					await this.onResourcesListChanged();
+					break;
+				case "notifications/prompts/list_changed":
+					await this.onPromptsListChanged();
+					break;
+				default: break;
+			}
+			await this.forwardNotification(e);
+		};
+		let e = this.client._notificationHandlers;
+		for (let t of ["notifications/progress", "notifications/cancelled"]) {
+			let n = e.get(t);
+			n && e.set(t, async (e) => {
+				await n(e), await this.forwardNotification(e);
+			});
+		}
+	}
+	setupRoundProgressForwarding() {
+		if (!this.client) return;
+		let e = this.client, t = e._onnotification.bind(this.client);
+		e._onnotification = async (e) => {
+			e && typeof e == "object" && e.method === "notifications/progress" && this.forwardRoundProgress(e.params), await t?.(e);
+		};
+	}
+	forwardRoundProgress(e) {
+		if (this.activeProgressHandlers.size === 1) {
+			let [t] = this.activeProgressHandlers;
+			t?.(e);
+		}
+	}
+	async refreshToolsCache() {
+		if (this.client) try {
+			b.debug("[Auto] Refreshing tools cache due to list_changed notification");
+			let e = await this.client.listTools();
+			this.toolsCache = e.tools ?? [], b.debug(`[Auto] Refreshed tools cache: ${this.toolsCache.length} tools`);
+		} catch (e) {
+			b.warn("[Auto] Failed to refresh tools cache:", e);
+		}
+	}
+	async onResourcesListChanged() {
+		b.debug("[Auto] Resources list changed - clients should re-fetch if needed");
+	}
+	async onPromptsListChanged() {
+		b.debug("[Auto] Prompts list changed - clients should re-fetch if needed");
+	}
+	async setRoots(e) {
+		this.rootsCache = [...e], this.client && (b.debug(`Sending roots/list_changed notification with ${e.length} root(s)`), await this.client.sendRootsListChanged());
+	}
+	getRoots() {
+		return [...this.rootsCache];
+	}
+	setupRootsHandler() {
+		this.client && this.client.setRequestHandler("roots/list", async () => (b.debug(`Server requested roots list, returning ${this.rootsCache.length} root(s)`), { roots: this.rootsCache }));
+	}
+	setupSamplingHandler() {
+		if (!this.client) {
+			b.debug("setupSamplingHandler: No client available");
+			return;
+		}
+		let e = this.opts.onSampling;
+		if (!e) {
+			b.debug("setupSamplingHandler: No sampling callback provided");
+			return;
+		}
+		b.debug("setupSamplingHandler: Setting up sampling request handler"), this.client.setRequestHandler("sampling/createMessage", async (t) => (b.debug("Server requested sampling, forwarding to callback"), await e(t.params))), b.debug("setupSamplingHandler: Sampling handler registered successfully");
+	}
+	setupElicitationHandler() {
+		if (!this.client) {
+			b.debug("setupElicitationHandler: No client available");
+			return;
+		}
+		let e = this.opts.onElicitation;
+		if (!e) {
+			b.debug("setupElicitationHandler: No elicitation callback provided");
+			return;
+		}
+		b.debug("setupElicitationHandler: Setting up elicitation request handler"), this.client.setRequestHandler("elicitation/create", async (t) => (b.debug("Server requested elicitation, forwarding to callback"), await e(t.params))), b.debug("setupElicitationHandler: Elicitation handler registered successfully");
+	}
+	async disconnect() {
+		if (!this.connected) {
+			b.debug("Not connected to MCP implementation");
+			return;
+		}
+		b.debug("Disconnecting from MCP implementation"), await this.cleanupResources(), this.connected = !1, b.debug("Disconnected from MCP implementation");
+	}
+	get isClientConnected() {
+		return this.client != null;
+	}
+	async initialize(e = this.opts.defaultRequestOptions ?? {}) {
+		if (!this.client) throw Error("MCP client is not connected");
+		b.debug("Caching server capabilities & tools");
+		let t = this.client.getServerCapabilities();
+		this.capabilitiesCache = t || null;
+		let n = this.client.getServerVersion();
+		this.serverInfoCache = n ? {
+			name: n.name,
+			version: n.version,
+			title: n.title,
+			description: n.description,
+			websiteUrl: n.websiteUrl,
+			icons: n.icons
+		} : null;
+		try {
+			let t = await this.client.listTools(void 0, e);
+			this.toolsCache = t.tools ?? [], b.debug(`Fetched ${this.toolsCache.length} tools from server`);
+		} catch (e) {
+			let t = e;
+			t.code === -32601 ? b.debug("Server does not implement tools/list, assuming no tools") : b.debug("Failed to list tools, assuming empty:", t.message), this.toolsCache = [];
+		}
+		return b.debug("Server capabilities:", t), b.debug("Server info:", n), t;
+	}
+	get tools() {
+		if (!this.toolsCache) throw Error("MCP client is not initialized; call initialize() first");
+		return this.toolsCache;
+	}
+	get serverCapabilities() {
+		return this.capabilitiesCache || {};
+	}
+	get serverInfo() {
+		return this.serverInfoCache;
+	}
+	get instructions() {
+		return this.client?.getInstructions?.();
+	}
+	get protocolEra() {
+		return this.client?.getProtocolEra?.();
+	}
+	get negotiatedProtocolVersion() {
+		return this.client?.getNegotiatedProtocolVersion?.();
+	}
+	async callTool(e, t, n) {
+		if (!this.client) throw Error("MCP client is not connected");
+		let r = n ? { ...n } : void 0;
+		r?.resetTimeoutOnProgress && !r.onprogress && (r.onprogress = () => {}, b.debug(`[BaseConnector] Added onprogress callback for tool '${e}' to enable progressToken`)), b.debug(`Calling tool '${e}' with args`, t);
+		let i = r?.onprogress;
+		i && this.activeProgressHandlers.add(i);
+		try {
+			let n = await this.client.callTool({
+				name: e,
+				arguments: t
+			}, r);
+			return b.debug(`Tool '${e}' returned`, n), n;
+		} finally {
+			i && this.activeProgressHandlers.delete(i);
+		}
+	}
+	async listTools(e) {
+		if (!this.client) throw Error("MCP client is not connected");
+		b.debug("[listTools] Fetching fresh tools from server...");
+		let t = await this.client.listTools(void 0, e), n = t.tools ? [...t.tools] : [];
+		return b.debug(`[listTools] Returned ${n.length} tools:`, n.map((e) => e.name)), n;
+	}
+	async listResources(e, t) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug("Listing resources", e ? `with cursor: ${e}` : ""), await this.client.listResources({ cursor: e }, t);
+	}
+	async listAllResources(e) {
+		if (!this.client) throw Error("MCP client is not connected");
+		if (!this.capabilitiesCache?.resources) return b.debug("Server does not advertise resources capability, skipping"), { resources: [] };
+		try {
+			b.debug("Listing all resources (with auto-pagination)");
+			let t = [], n;
+			do {
+				let r = await this.client.listResources({ cursor: n }, e);
+				t.push(...r.resources || []), n = r.nextCursor;
+			} while (n);
+			return { resources: t };
+		} catch (e) {
+			if (e.code === -32601) return b.debug("Server advertised resources but method not found"), { resources: [] };
+			throw e;
+		}
+	}
+	async listResourceTemplates(e) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug("Listing resource templates"), await this.client.listResourceTemplates(void 0, e);
+	}
+	async complete(e, t) {
+		if (!this.client) throw Error("MCP client is not connected");
+		b.debug("[complete] Requesting completions for:", e.ref);
+		let n = await this.client.complete(e, t);
+		return b.debug(`[complete] Received ${n.completion.values.length} suggestions`), n;
+	}
+	async readResource(e, t) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug(`Reading resource ${e}`), await this.client.readResource({ uri: e }, t);
+	}
+	async subscribeToResource(e, t) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug(`Subscribing to resource: ${e}`), await this.client.subscribeResource({ uri: e }, t);
+	}
+	async unsubscribeFromResource(e, t) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug(`Unsubscribing from resource: ${e}`), await this.client.unsubscribeResource({ uri: e }, t);
+	}
+	async listPrompts() {
+		if (!this.client) throw Error("MCP client is not connected");
+		if (!this.capabilitiesCache?.prompts) return b.debug("Server does not advertise prompts capability, skipping"), { prompts: [] };
+		try {
+			return b.debug("Listing prompts"), await this.client.listPrompts();
+		} catch (e) {
+			if (e.code === -32601) return b.debug("Server advertised prompts but method not found"), { prompts: [] };
+			throw e;
+		}
+	}
+	async getPrompt(e, t) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug(`Getting prompt ${e}`), await this.client.getPrompt({
+			name: e,
+			arguments: t
+		});
+	}
+	async request(e, t = null, n) {
+		if (!this.client) throw Error("MCP client is not connected");
+		return b.debug(`Sending raw request '${e}' with params`, t), await this.client.request({
+			method: e,
+			params: t ?? {}
+		}, Ne, n);
+	}
+	async cleanupResources() {
+		let e = [];
+		if (this.client) try {
+			typeof this.client.close == "function" && await this.client.close();
+		} catch (t) {
+			let n = `Error closing client: ${t}`;
+			b.warn(n), e.push(n);
+		} finally {
+			this.client = null;
+		}
+		if (this.connectionManager) try {
+			await this.connectionManager.stop();
+		} catch (t) {
+			let n = `Error stopping connection manager: ${t}`;
+			b.warn(n), e.push(n);
+		} finally {
+			this.connectionManager = null;
+		}
+		this.toolsCache = null, e.length && b.warn(`Resource cleanup finished with ${e.length} issue(s)`);
+	}
+};
+function J(e, t = 0) {
+	if (!e || t > 5) return !1;
+	if (e instanceof s || e instanceof i && e.status === 401) return !0;
+	if (e instanceof Error) {
+		if (e.cause && J(e.cause, t + 1)) return !0;
+		let r = e instanceof n ? e.data : void 0;
+		if (r?.cause && J(r.cause, t + 1)) return !0;
+	}
+	return !1;
+}
+function Pe(e, t, n, r) {
+	let i = new URL(e), a = t.replace(/\/$/, "");
+	return async (e, t) => {
+		let o = new Request(e, t), s = new URL(o.url);
+		if (!(s.origin === i.origin && s.pathname === i.pathname)) return n(o);
+		let c = new Headers(o.headers);
+		c.set("X-Target-URL", o.url), r && c.set("X-Server-Id", r);
+		let l = o.method === "GET" || o.method === "HEAD" ? void 0 : await o.clone().arrayBuffer();
+		return n(new Request(a, {
+			method: o.method,
+			headers: c,
+			body: l,
+			signal: o.signal,
+			redirect: "manual"
+		}));
+	};
+}
+var Y = class extends q {
+	baseUrl;
+	headers;
+	timeout;
+	customFetch;
+	clientInfo;
+	protocolNegotiation;
+	gatewayUrl;
+	serverId;
+	reconnectionOptions;
+	transportType = null;
+	streamableTransport = null;
+	constructor(e, t = {}) {
+		super(t);
+		let n = e.replace(/\/$/, "");
+		this.baseUrl = n, this.headers = { ...t.headers ?? {} }, this.gatewayUrl = t.gatewayUrl, this.serverId = t.serverId, t.authToken && (this.headers.Authorization = `Bearer ${t.authToken}`), this.timeout = t.timeout ?? 1e4;
+		let r = t.fetch ?? globalThis.fetch.bind(globalThis);
+		this.customFetch = this.gatewayUrl ? Pe(n, this.gatewayUrl, r, this.serverId) : t.fetch, this.clientInfo = t.clientInfo ?? {
+			name: "http-connector",
+			version: "1.0.0"
+		}, this.protocolNegotiation = t.protocolNegotiation ?? "auto", this.reconnectionOptions = t.reconnectionOptions;
+	}
+	buildClientOptions() {
+		return {
+			...this.opts.clientOptions || {},
+			jsonSchemaValidator: this.opts.clientOptions?.jsonSchemaValidator ?? new K(),
+			versionNegotiation: {
+				mode: this.protocolNegotiation,
+				...this.opts.clientOptions?.versionNegotiation ?? {}
+			},
+			listChanged: {
+				tools: {
+					autoRefresh: !0,
+					onChanged: (e, t) => void this.handleListChanged("notifications/tools/list_changed", e, t)
+				},
+				resources: {
+					autoRefresh: !1,
+					onChanged: (e) => void this.handleListChanged("notifications/resources/list_changed", e)
+				},
+				prompts: {
+					autoRefresh: !1,
+					onChanged: (e) => void this.handleListChanged("notifications/prompts/list_changed", e)
+				},
+				...this.opts.clientOptions?.listChanged ?? {}
+			},
+			capabilities: {
+				...this.opts.clientOptions?.capabilities || {},
+				roots: { listChanged: !0 },
+				...this.opts.onSampling ? { sampling: {} } : {},
+				...this.opts.onElicitation ? { elicitation: {
+					form: {},
+					url: {}
+				} } : {}
+			}
+		};
+	}
+	unwrapStreamableError(e) {
+		return e instanceof i ? e : e instanceof Error && e.cause instanceof i ? e.cause : null;
+	}
+	classifyStreamableHttpFailure(e) {
+		let t = "Unknown error", n = !1, r, i = this.unwrapStreamableError(e);
+		if (i) {
+			let e = i.status;
+			return n = e === 401, r = e, e === 400 && i.message.includes("Missing session ID") ? (t = "Server requires session ID (FastMCP compatibility)", b.warn(`\u26A0\uFE0F  ${t}`)) : e === 404 || e === 405 ? (t = `Server returned ${e} - server likely doesn't support streamable HTTP`, b.debug(t)) : (t = `Server returned ${e}: ${i.message}`, b.debug(t)), {
+				fallbackReason: t,
+				is401Error: n,
+				httpStatusCode: r
+			};
+		}
+		if (e instanceof Error) {
+			let r = e.toString(), i = e.message || "";
+			n = J(e) || r.includes("401") || i.includes("Unauthorized"), r.includes("Missing session ID") || r.includes("Bad Request: Missing session ID") || i.includes("FastMCP session ID error") ? (t = "Server requires session ID (FastMCP compatibility)", b.warn(`\u26A0\uFE0F  ${t}`)) : r.includes("405 Method Not Allowed") || r.includes("404 Not Found") ? (t = "Server doesn't support streamable HTTP (405/404)", b.debug(t)) : (t = `Streamable HTTP failed: ${e.message}`, b.debug(t));
+		}
+		return {
+			fallbackReason: t,
+			is401Error: n,
+			httpStatusCode: r
+		};
+	}
+	async connect() {
+		if (this.connected) {
+			b.debug("Already connected to MCP implementation");
+			return;
+		}
+		let e = this.baseUrl;
+		b.debug(`Connecting to MCP implementation via HTTP: ${e}`);
+		try {
+			await this.connectWithStreamableHttp(e), b.debug("✅ Successfully connected via streamable HTTP");
+		} catch (e) {
+			b.debug("Streamable HTTP connect failed", e);
+			let { fallbackReason: t, is401Error: n, httpStatusCode: r } = this.classifyStreamableHttpFailure(e);
+			if (await this.cleanupResources(), n) {
+				b.info("Authentication required");
+				let e = /* @__PURE__ */ Error("Authentication required");
+				throw e.code = 401, e;
+			}
+			let i = /* @__PURE__ */ Error(`Could not connect via streamable HTTP: ${t}`);
+			throw r !== void 0 && Object.defineProperty(i, "code", {
+				value: r,
+				writable: !1,
+				enumerable: !0,
+				configurable: !0
+			}), i;
+		}
+	}
+	observeSseProgress(e) {
+		if (!e.body || !e.headers.get("content-type")?.includes("text/event-stream")) return e;
+		let [t, n] = e.body.tee();
+		return (async () => {
+			let e = n.getReader(), t = new TextDecoder(), r = "";
+			try {
+				for (;;) {
+					let { done: n, value: i } = await e.read();
+					if (n) break;
+					r += t.decode(i, { stream: !0 });
+					let a = r.split(/\r?\n\r?\n/);
+					r = a.pop() ?? "";
+					for (let e of a) for (let t of e.split(/\r?\n/)) if (t.startsWith("data:")) try {
+						let e = JSON.parse(t.slice(5).trim());
+						e.method === "notifications/progress" && this.forwardRoundProgress(e.params);
+					} catch {}
+				}
+			} catch (e) {
+				e instanceof DOMException && e.name === "AbortError" || b.debug("Progress observer stream ended:", e);
+			} finally {
+				e.releaseLock();
+			}
+		})(), new Response(t, {
+			status: e.status,
+			statusText: e.statusText,
+			headers: e.headers
+		});
+	}
+	async connectWithStreamableHttp(e) {
+		try {
+			b.debug("[HttpConnector] Connecting with Streamable HTTP", {
+				baseUrl: e,
+				originalUrl: this.baseUrl,
+				gatewayUrl: this.gatewayUrl || "none",
+				authProviderUrl: this.opts.authProvider && "serverUrl" in this.opts.authProvider && typeof this.opts.authProvider.serverUrl == "string" ? this.opts.authProvider.serverUrl : "none",
+				headers: this.headers
+			});
+			let t, n = new Promise((e) => {
+				t = e;
+			}), r = this.customFetch ?? globalThis.fetch.bind(globalThis), i = new a(new URL(e), {
+				authProvider: this.opts.authProvider,
+				fetch: async (e, n) => {
+					let i = await r(e, n), a = n?.method ?? (e instanceof Request ? e.method : "GET"), o = new Headers(e instanceof Request ? e.headers : void 0);
+					return new Headers(n?.headers).forEach((e, t) => {
+						o.set(t, e);
+					}), a.toUpperCase() === "GET" && i.ok && i.headers.get("content-type")?.includes("text/event-stream") && t?.(), o.get("mcp-method") === "subscriptions/listen" ? i : this.observeSseProgress(i);
+				},
+				requestInit: { headers: this.headers },
+				reconnectionOptions: {
+					maxReconnectionDelay: 3e4,
+					initialReconnectionDelay: 1e3,
+					reconnectionDelayGrowFactor: 1.5,
+					maxRetries: 2,
+					...this.reconnectionOptions
+				}
+			}), o = i;
+			if (this.opts.wrapTransport) {
+				let e = this.baseUrl;
+				o = this.opts.wrapTransport(o, e);
+			}
+			let s = this.buildClientOptions();
+			b.debug("Creating Client with capabilities:", JSON.stringify(s.capabilities, null, 2)), this.client = new c(this.clientInfo, s), this.setupRootsHandler(), this.setupSamplingHandler(), this.setupElicitationHandler(), b.debug("Roots/sampling/elicitation handlers registered before connect");
+			try {
+				let e;
+				if (await Promise.race([this.client.connect(o), new Promise((t, n) => {
+					e = setTimeout(() => n(/* @__PURE__ */ Error(`MCP connection timed out after ${this.timeout}ms`)), this.timeout);
+				})]).finally(() => {
+					e !== void 0 && clearTimeout(e);
+				}), (this.client.getProtocolEra?.() ?? "legacy") === "legacy" && i.sessionId) {
+					let e, t = await Promise.race([n.then(() => !0), new Promise((t) => e = setTimeout(() => t(!1), Math.min(this.timeout, 5e3)))]);
+					e && clearTimeout(e), t || b.warn("Legacy server push stream did not attach before connect completed");
+				}
+				let t = i.sessionId;
+				t && b.debug(`Session ID obtained: ${t}`);
+			} catch (e) {
+				if (e instanceof Error) {
+					let t = e.message || e.toString();
+					if (t.includes("Missing session ID") || t.includes("Bad Request: Missing session ID") || t.includes("Mcp-Session-Id header is required")) {
+						let n = /* @__PURE__ */ Error(`Session ID error: ${t}. The SDK should automatically extract session ID from initialize response.`);
+						throw n.cause = e, n;
+					}
+				}
+				throw e;
+			}
+			this.streamableTransport = i, this.connectionManager = { stop: async () => {
+				if (this.streamableTransport) try {
+					await this.streamableTransport.close();
+				} catch (e) {
+					b.warn(`Error closing Streamable HTTP transport: ${e}`);
+				} finally {
+					this.streamableTransport = null;
+				}
+			} }, this.connected = !0, this.transportType = "streamable-http", this.setupNotificationHandler(), b.debug(`Successfully connected to MCP implementation via streamable HTTP: ${e}`), this.trackConnectorInit({
+				serverUrl: this.baseUrl,
+				publicIdentifier: `${this.baseUrl} (streamable-http)`
+			});
+		} catch (e) {
+			throw await this.cleanupResources(), e;
+		}
+	}
+	get publicIdentifier() {
+		return {
+			type: "http",
+			url: this.baseUrl,
+			transport: this.transportType || "unknown",
+			protocolEra: this.protocolEra ?? "unknown"
+		};
+	}
+	getTransportType() {
+		return this.transportType;
+	}
+	async cleanupResources() {
+		if (this.streamableTransport && this.protocolEra !== "modern") {
+			let e;
+			try {
+				await Promise.race([this.streamableTransport.terminateSession().then(() => !0), new Promise((t) => e = setTimeout(() => t(!1), Math.min(this.timeout, 5e3)))]) || b.debug("Timed out terminating legacy HTTP session; closing transport");
+			} catch (e) {
+				b.debug(`Error terminating Streamable HTTP session: ${e}`);
+			} finally {
+				e && clearTimeout(e);
+			}
+		}
+		await super.cleanupResources();
+	}
+};
+function X(e, t) {
+	return {
+		onSampling: e?.onSampling ?? t?.onSampling,
+		onElicitation: e?.onElicitation ?? t?.onElicitation,
+		onNotification: e?.onNotification ?? t?.onNotification
+	};
+}
+function Z(e) {
+	if (!("url" in e) || typeof e.url != "string" || e.authProvider || e.authToken || e.oauth === !1) return !1;
+	let t = e.headers;
+	if (t) {
+		for (let e of Object.keys(t)) if (e.toLowerCase() === "authorization") return !1;
+	}
+	return !0;
+}
+function Fe() {
+	return {
+		name: "mcp-use",
+		title: "mcp-use",
+		version: S(),
+		description: "mcp-use is a complete TypeScript framework for building and using MCP",
+		icons: [{ src: "https://mcp-use.com/logo.png" }],
+		websiteUrl: "https://mcp-use.com"
+	};
+}
+function Q(e) {
+	let t = Fe();
+	if (!e || typeof e != "object") return t;
+	let n = e;
+	return !n.name || !n.version ? t : {
+		...t,
+		...n
+	};
+}
+var $ = class {
+	connector;
+	autoConnect;
+	constructor(e, t = !0) {
+		this.connector = e, this.autoConnect = t;
+	}
+	async connect() {
+		await this.connector.connect();
+	}
+	async disconnect() {
+		await this.connector.disconnect();
+	}
+	async initialize() {
+		!this.isConnected && this.autoConnect && await this.connect(), await this.connector.initialize();
+	}
+	get isConnected() {
+		return this.connector && this.connector.isClientConnected;
+	}
+	on(e, t) {
+		e === "notification" && this.connector.onNotification(t);
+	}
+	async setRoots(e) {
+		return this.connector.setRoots(e);
+	}
+	getRoots() {
+		return this.connector.getRoots();
+	}
+	get tools() {
+		return this.connector.tools;
+	}
+	async listTools(e) {
+		return this.connector.listTools(e);
+	}
+	get serverCapabilities() {
+		return this.connector.serverCapabilities;
+	}
+	get serverInfo() {
+		return this.connector.serverInfo;
+	}
+	get protocolEra() {
+		return this.connector.protocolEra;
+	}
+	get negotiatedProtocolVersion() {
+		return this.connector.negotiatedProtocolVersion;
+	}
+	get info() {
+		let e = this.protocolEra, t = this.negotiatedProtocolVersion, n = this.serverInfo;
+		if (!e || !t || !n) throw Error("MCP connection is not initialized");
+		let r = this.serverCapabilities, i = r.extensions && typeof r.extensions == "object" && !Array.isArray(r.extensions) ? r.extensions : {};
+		return {
+			protocolEra: e,
+			protocolVersion: t,
+			server: n,
+			capabilities: r,
+			instructions: this.connector.instructions,
+			extensions: i
+		};
+	}
+	supports(e) {
+		return e in this.serverCapabilities;
+	}
+	async callTool(e, t = {}, n) {
+		return this.connector.callTool(e, t, n);
+	}
+	async listResources(e, t) {
+		return this.connector.listResources(e, t);
+	}
+	async listAllResources(e) {
+		return this.connector.listAllResources(e);
+	}
+	async listResourceTemplates(e) {
+		return this.connector.listResourceTemplates(e);
+	}
+	async complete(e, t) {
+		return this.connector.complete(e, t);
+	}
+	async readResource(e, t) {
+		return this.connector.readResource(e, t);
+	}
+	async subscribeToResource(e, t) {
+		return this.connector.subscribeToResource(e, t);
+	}
+	async unsubscribeFromResource(e, t) {
+		return this.connector.unsubscribeFromResource(e, t);
+	}
+	async listPrompts() {
+		return this.connector.listPrompts();
+	}
+	async getPrompt(e, t) {
+		return this.connector.getPrompt(e, t);
+	}
+	async request(e, t = null, n) {
+		return this.connector.request(e, t, n);
+	}
+};
+function Ie(e) {
+	return !!e && typeof e == "object" && "redirectUrl" in e && "clientMetadata" in e;
+}
+var Le = class {
+	config = {};
+	sessions = {};
+	activeSessions = [];
+	constructor(e) {
+		e && (this.config = e);
+	}
+	static fromDict(e) {
+		throw Error("fromDict must be implemented by concrete class");
+	}
+	addServer(e, t) {
+		this.config.mcpServers = this.config.mcpServers || {}, this.config.mcpServers[e] = t, f(e, t);
+	}
+	async removeServer(e) {
+		this.config.mcpServers?.[e] && (await this.closeSession(e), delete this.config.mcpServers[e], p(e));
+	}
+	getServerNames() {
+		return Object.keys(this.config.mcpServers ?? {});
+	}
+	getServerConfig(e) {
+		return this.config.mcpServers?.[e];
+	}
+	getConfig() {
+		return this.config ?? {};
+	}
+	async createSession(e, t = !0) {
+		let n = this.config.mcpServers ?? {};
+		if (Object.keys(n).length === 0 && b.warn("No MCP servers defined in config"), !n[e]) throw Error(`Server '${e}' not found in config`);
+		let r = { ...n[e] }, i;
+		if (Z(r)) {
+			let e = r.oauth === !1 ? void 0 : r.oauth ?? {};
+			i = await this.createDefaultOAuthProvider(r.url, e), r = {
+				...r,
+				authProvider: i
+			};
+		} else "authProvider" in r && r.authProvider && Ie(r.authProvider) && (i = r.authProvider);
+		let a = async () => {
+			let e = new $(await Promise.resolve(this.createConnectorFromConfig(r)));
+			return t && await e.initialize(), e;
+		}, o;
+		try {
+			o = await a();
+		} catch (n) {
+			let s = r;
+			if (!t || !i || !("url" in s) || !U(n) || i.preventAutoAuth) throw n;
+			b.info(`[MCPClient] Unauthorized connecting to '${e}'; completing OAuth\u2026`), await W(i, s.url), o = await a();
+		}
+		return this.sessions[e] = o, this.activeSessions.includes(e) || this.activeSessions.push(e), o;
+	}
+	async connect(e) {
+		return this.createSession(e);
+	}
+	async createAllSessions(e = !0) {
+		let t = this.config.mcpServers ?? {};
+		Object.keys(t).length === 0 && b.warn("No MCP servers defined in config");
+		for (let n of Object.keys(t)) await this.createSession(n, e);
+		return this.sessions;
+	}
+	async connectAll() {
+		return this.createAllSessions();
+	}
+	getSession(e) {
+		return this.sessions[e] || null;
+	}
+	requireSession(e) {
+		let t = this.sessions[e];
+		if (!t) throw Error(`Session '${e}' not found. Available sessions: ${this.activeSessions.join(", ") || "none"}`);
+		return t;
+	}
+	getAllActiveSessions() {
+		return Object.fromEntries(this.activeSessions.map((e) => [e, this.sessions[e]]));
+	}
+	async closeSession(e) {
+		let t = this.sessions[e];
+		if (!t) {
+			b.warn(`No session exists for server ${e}, nothing to close`);
+			return;
+		}
+		try {
+			b.debug(`Closing session for server ${e}`), await t.disconnect();
+		} catch (t) {
+			b.error(`Error closing session for server '${e}': ${t}`);
+		} finally {
+			this.sessions[e] === t && (delete this.sessions[e], this.activeSessions = this.activeSessions.filter((t) => t !== e));
+		}
+	}
+	async closeAllSessions() {
+		let e = Object.keys(this.sessions), t = [];
+		for (let n of e) try {
+			b.debug(`Closing session for server ${n}`), await this.closeSession(n);
+		} catch (e) {
+			let r = `Failed to close session for server '${n}': ${e}`;
+			b.error(r), t.push(r);
+		}
+		t.length ? b.error(`Encountered ${t.length} errors while closing sessions`) : b.debug("All sessions closed successfully");
+	}
+	async close() {
+		await this.closeAllSessions();
+	}
+};
+function Re(e) {
+	let t = Object.keys(e.mcpServers ?? {});
+	L.getInstance().trackMCPClientInit({
+		codeMode: !1,
+		sandbox: !1,
+		allCallbacks: !1,
+		verify: !1,
+		servers: t,
+		numServers: t.length,
+		isBrowser: !0
+	}).catch((e) => b.debug(`Failed to track BrowserMCPClient init: ${e}`));
+}
+var ze = class e extends Le {
+	static getPackageVersion() {
+		return S();
+	}
+	constructor(e) {
+		super(e), Re(this.config);
+	}
+	static fromDict(t) {
+		return new e(t);
+	}
+	async createDefaultOAuthProvider(e, t = {}) {
+		return V(e, t);
+	}
+	createConnectorFromConfig(e) {
+		let { url: t, headers: n, fetch: r, authToken: i, authProvider: a, wrapTransport: o, clientOptions: s, protocolNegotiation: c, timeout: l, gatewayUrl: u, serverId: d, reconnectionOptions: f } = e;
+		if (!t) throw Error("Server URL is required");
+		let p = this.config, m = X(e, p), h = Q(e.clientInfo ?? this.config.clientInfo), g = {
+			headers: n,
+			fetch: r ?? globalThis.fetch.bind(globalThis),
+			authToken: i,
+			authProvider: a,
+			wrapTransport: o,
+			clientOptions: s,
+			onSampling: m.onSampling,
+			onElicitation: m.onElicitation,
+			onNotification: m.onNotification,
+			protocolNegotiation: c,
+			timeout: l,
+			clientInfo: h,
+			gatewayUrl: u,
+			serverId: d,
+			reconnectionOptions: f
+		};
+		return b.debug(`[BrowserMCPClient] Connector options prepared (clientOptions: ${s ? "provided" : "none"})`), new Y(t, g);
+	}
+};
+//#endregion
+export { b as a, l as i, L as n, R as o, k as r, T as t };