@mcp-b/webmcp-local-relay 2.0.12 → 2.1.0

package/dist/{mcpRelayServer-DAp7h9b1.js → mcpRelayServer-rbay_DSr.js}

@@ -1,11 +1,15 @@
 import { execFile } from "node:child_process";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestParamsSchema, CallToolResultSchema, ListToolsRequestSchema, ToolAnnotationsSchema, ToolSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod/v4";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import WebSocket, { WebSocketServer } from "ws";
-import { CallToolRequestParamsSchema, CallToolResultSchema, ToolAnnotationsSchema, ToolSchema } from "@modelcontextprotocol/sdk/types.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
 
 //#region src/cli-utils.ts
 /**
@@ -15,6 +19,7 @@ function parseCliOptions(argv) {
 	const options = {
 		host: "127.0.0.1",
 		port: 9333,
+		portExplicitlySet: false,
 		allowedOrigins: ["*"]
 	};
 	const readFlagValue = (flag, index) => {
@@ -36,6 +41,7 @@ function parseCliOptions(argv) {
 			const value = Number.parseInt(raw, 10);
 			if (!Number.isFinite(value) || value <= 0 || value > 65535) throw new Error(`Invalid port "${raw}". Port must be a number between 1 and 65535.`);
 			options.port = value;
+			options.portExplicitlySet = true;
 			continue;
 		}
 		if (token === "--widget-origin" || token === "--allowed-origin" || token === "--ws-origin") {
@@ -45,6 +51,21 @@ function parseCliOptions(argv) {
 			if (split.length > 0) options.allowedOrigins = split;
 			continue;
 		}
+		if (token === "--label") {
+			options.label = readFlagValue(token, i);
+			i += 1;
+			continue;
+		}
+		if (token === "--workspace") {
+			options.workspace = readFlagValue(token, i);
+			i += 1;
+			continue;
+		}
+		if (token === "--relay-id") {
+			options.relayId = readFlagValue(token, i);
+			i += 1;
+			continue;
+		}
 		if (token === "--help" || token === "-h") {
 			printHelp();
 			process.exit(0);
@@ -66,15 +87,76 @@ function printHelp() {
 		"",
 		"Options:",
 		"  --host, -H               Bind host for local websocket relay (default: 127.0.0.1)",
-		"  --port, -p               Bind port for local websocket relay (default: 9333)",
+		"  --port, -p               Preferred root port for the local relay cluster (default: 9333)",
 		"  --widget-origin          Allowed host page origin(s), comma-separated (default: *)",
 		"  --allowed-origin         Alias for --widget-origin",
 		"  --ws-origin              Alias for --widget-origin",
+		"  --label                  Human-readable relay label reported during discovery",
+		"  --workspace              Optional workspace name reported during discovery",
+		"  --relay-id               Stable relay identifier reported during discovery",
 		"  --help, -h               Show help",
 		""
 	].join("\n"));
 }
 
+//#endregion
+//#region src/portStrategy.ts
+const DEFAULT_RELAY_PORT = 9333;
+const DEFAULT_RELAY_PORT_RANGE_END = 9348;
+const RELAY_PORT_CACHE_MAX_AGE_MS = 1440 * 60 * 1e3;
+function defaultRelayPortPersistPath() {
+	return join(homedir(), ".webmcp", "relay-port.json");
+}
+async function persistPort(port, path = defaultRelayPortPersistPath(), host = "127.0.0.1", now = Date.now()) {
+	const payload = {
+		port,
+		host,
+		updatedAt: new Date(now).toISOString()
+	};
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+async function readPersistedPort(path = defaultRelayPortPersistPath(), options = {}) {
+	try {
+		const raw = await readFile(path, "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.port !== "number" || !Number.isInteger(parsed.port) || parsed.port < 1 || parsed.port > 65535) return null;
+		if (typeof parsed.host !== "string" || parsed.host.length === 0) return null;
+		if (options.expectedHost && parsed.host !== options.expectedHost) return null;
+		const maxAgeMs = options.maxAgeMs ?? RELAY_PORT_CACHE_MAX_AGE_MS;
+		const now = options.now ?? Date.now();
+		const updatedAtMs = typeof parsed.updatedAt === "string" ? Date.parse(parsed.updatedAt) : NaN;
+		if (!Number.isFinite(updatedAtMs) || now - updatedAtMs > maxAgeMs) return null;
+		return parsed.port;
+	} catch {
+		return null;
+	}
+}
+async function buildPortCandidates(options) {
+	const { defaultPort, fixedPort, host, persistPath = defaultRelayPortPersistPath(), rangeEnd } = options;
+	if (fixedPort !== void 0) return [{
+		port: fixedPort,
+		wasFixed: true,
+		fromCache: false
+	}];
+	const cachedPort = await readPersistedPort(persistPath, { expectedHost: host });
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	const pushCandidate = (port, fromCache) => {
+		if (port < 1 || port > 65535 || seen.has(port)) return;
+		seen.add(port);
+		candidates.push({
+			port,
+			wasFixed: false,
+			fromCache
+		});
+	};
+	if (cachedPort !== null && cachedPort >= defaultPort && cachedPort <= rangeEnd) pushCandidate(cachedPort, true);
+	pushCandidate(defaultPort, false);
+	for (let port = defaultPort + 1; port <= rangeEnd; port += 1) pushCandidate(port, false);
+	return candidates;
+}
+
 //#endregion
 //#region src/protocol.ts
 /**
@@ -447,6 +529,26 @@ const BrowserToRelayMessageSchema = z.discriminatedUnion("type", [
 	BrowserPongMessageSchema
 ]);
 /**
+* Shared relay identity used for discovery and attach verification.
+*/
+const RelayDescriptorSchema = z.object({
+	host: z.string().min(1),
+	instanceId: z.string().min(1),
+	label: z.string().min(1).optional(),
+	port: z.number().int().min(1).max(65535),
+	relayId: z.string().min(1).optional(),
+	workspace: z.string().min(1).optional()
+});
+/**
+* Schema for server hello messages sent immediately after WebSocket connect.
+*/
+const ServerHelloMessageSchema = z.object({
+	type: z.literal("server-hello"),
+	service: z.literal("webmcp-local-relay"),
+	version: z.literal(1),
+	...RelayDescriptorSchema.shape
+});
+/**
 * Schema for relay invocation messages sent to browser sources.
 */
 const RelayInvokeMessageSchema = z.object({
@@ -467,6 +569,7 @@ const RelayReloadMessageSchema = z.object({ type: z.literal("reload") });
 * Union schema for all relay-to-browser protocol messages.
 */
 const RelayToBrowserMessageSchema = z.discriminatedUnion("type", [
+	ServerHelloMessageSchema,
 	RelayInvokeMessageSchema,
 	RelayPingMessageSchema,
 	RelayReloadMessageSchema
@@ -515,8 +618,8 @@ const RelayClientToServerMessageSchema = z.discriminatedUnion("type", [
 ]);
 const RelayToolsPayloadFields = {
 	tools: z.array(NormalizedToolSchema),
-	sources: z.array(RelaySourceInfoSchema),
-	toolSourceMap: z.record(z.string(), z.array(z.string()))
+	sources: z.array(RelaySourceInfoSchema).optional().default([]),
+	toolSourceMap: z.record(z.string(), z.array(z.string())).optional().default({})
 };
 /**
 * Schema for relay server tool list response.
@@ -544,6 +647,7 @@ const RelayServerToolsChangedSchema = z.object({
 * Union schema for all relay-server-to-client messages.
 */
 const RelayServerToClientMessageSchema = z.discriminatedUnion("type", [
+	ServerHelloMessageSchema,
 	RelayServerToolsSchema,
 	RelayServerResultSchema,
 	RelayServerToolsChangedSchema
@@ -551,6 +655,17 @@ const RelayServerToClientMessageSchema = z.discriminatedUnion("type", [
 
 //#endregion
 //#region src/bridgeServer.ts
+const RELAY_BROWSER_PROTOCOL = "webmcp.v1";
+const RELAY_DISCOVERY_PROTOCOL = "webmcp-discovery.v1";
+const RELAY_INTERNAL_PROTOCOL = "webmcp-relay.v1";
+const RELAY_SERVER_MESSAGE_TIMEOUT_MS = 750;
+const HEARTBEAT_INTERVAL_MS = 15e3;
+const HEARTBEAT_DEAD_THRESHOLD_MS = 25e3;
+const SUPPORTED_SUBPROTOCOLS = new Set([
+	RELAY_BROWSER_PROTOCOL,
+	RELAY_DISCOVERY_PROTOCOL,
+	RELAY_INTERNAL_PROTOCOL
+]);
 /**
 * WebSocket relay between browser widget frames and MCP server calls.
 *
@@ -567,14 +682,24 @@ var RelayBridgeServer = class extends EventEmitter {
 	*/
 	registry;
 	host;
+	preferredPort;
 	desiredPort;
+	portExplicitlySet;
+	portRangeEnd;
+	persistPath;
 	allowedOrigins;
 	maxPayloadBytes;
 	invokeTimeoutMs;
+	label;
+	workspace;
+	relayId;
+	instanceId;
 	wss = null;
 	socketByConnectionId = /* @__PURE__ */ new Map();
 	pendingInvocations = /* @__PURE__ */ new Map();
 	relayClientConnectionIds = /* @__PURE__ */ new Set();
+	heartbeatIntervalByConnectionId = /* @__PURE__ */ new Map();
+	lastPongByConnectionId = /* @__PURE__ */ new Map();
 	onStateChangedPushRelay = () => {
 		this.pushToolsToRelayClients();
 	};
@@ -600,11 +725,20 @@ var RelayBridgeServer = class extends EventEmitter {
 		super();
 		this.registry = registry ?? new RelayRegistry();
 		this.host = options.host ?? "127.0.0.1";
-		this.desiredPort = options.port ?? 9333;
+		this.preferredPort = options.port ?? DEFAULT_RELAY_PORT;
+		this.desiredPort = this.preferredPort;
+		this.portExplicitlySet = options.portExplicitlySet ?? false;
+		this.portRangeEnd = options.portRangeEnd ?? Math.max(DEFAULT_RELAY_PORT_RANGE_END, this.preferredPort);
+		this.persistPath = options.persistPath ?? defaultRelayPortPersistPath();
 		this.allowedOrigins = options.allowedOrigins ?? ["*"];
 		this.maxPayloadBytes = options.maxPayloadBytes ?? 1e6;
 		this.invokeTimeoutMs = options.invokeTimeoutMs ?? 25e3;
-		if (this.desiredPort !== 0 && (this.desiredPort < 1 || this.desiredPort > 65535)) throw new Error(`Invalid port ${this.desiredPort}. Port must be 0 (auto-assign) or between 1 and 65535.`);
+		this.label = options.label;
+		this.workspace = options.workspace;
+		this.relayId = options.relayId;
+		this.instanceId = randomUUID();
+		if (this.preferredPort !== 0 && (this.preferredPort < 1 || this.preferredPort > 65535)) throw new Error(`Invalid port ${this.preferredPort}. Port must be 0 (auto-assign) or between 1 and 65535.`);
+		if (this.portRangeEnd < this.preferredPort && this.preferredPort !== 0) throw new Error(`Invalid port range ${this.preferredPort}-${this.portRangeEnd}. rangeEnd must be greater than or equal to the preferred port.`);
 		if (this.maxPayloadBytes <= 0) throw new Error(`Invalid maxPayloadBytes ${this.maxPayloadBytes}. Must be greater than 0.`);
 		if (this.invokeTimeoutMs <= 0) throw new Error(`Invalid invokeTimeoutMs ${this.invokeTimeoutMs}. Must be greater than 0.`);
 	}
@@ -645,19 +779,51 @@ var RelayBridgeServer = class extends EventEmitter {
 	}
 	/**
 	* Starts the bridge. Attempts to bind a WebSocket server (server mode).
-	* If the port is already in use, automatically falls back to client mode
-	* and proxies through the existing relay.
+	* If a compatible relay already owns a candidate port, joins it in client mode.
+	* If a non-relay process owns the port, continues searching the reserved range.
 	*/
 	async start() {
 		if (this.wss || this.clientSocket) return;
 		this.stopping = false;
-		try {
-			await this.startAsServer();
+		await this.startUsingPortStrategy();
+	}
+	async startUsingPortStrategy() {
+		if (this.preferredPort === 0) {
+			await this.startAsServer(0);
+			return;
+		}
+		const candidates = await buildPortCandidates({
+			defaultPort: this.preferredPort,
+			...this.portExplicitlySet ? { fixedPort: this.preferredPort } : {},
+			host: this.host,
+			persistPath: this.persistPath,
+			rangeEnd: this.portRangeEnd
+		});
+		for (const candidate of candidates) try {
+			await this.startAsServer(candidate.port);
+			await persistPort(this.port, this.persistPath, this.host);
+			return;
 		} catch (err) {
-			if (!(err instanceof Error && ("code" in err ? err.code === "EADDRINUSE" : err.message.includes("EADDRINUSE")))) throw err;
-			this._mode = "client";
-			process.stderr.write(`[webmcp-local-relay] info: port ${this.desiredPort} in use, switching to client mode\n`);
-			await this.startAsClient();
+			if (!this.isAddressInUseError(err)) throw err;
+			if (await this.tryAttachToExistingRelay(candidate.port)) {
+				await persistPort(this.port, this.persistPath, this.host);
+				return;
+			}
+			if (candidate.wasFixed) throw new Error(`Port ${candidate.port} is already in use by a non-WebMCP service and cannot be shared.`);
+			process.stderr.write(`[webmcp-local-relay] info: port ${candidate.port} is occupied by a non-relay service, trying next port\n`);
+		}
+		throw new Error(`No compatible relay port was available in the range ${this.preferredPort}-${this.portRangeEnd}.`);
+	}
+	isAddressInUseError(error) {
+		return error instanceof Error && ("code" in error ? error.code === "EADDRINUSE" : error.message.includes("EADDRINUSE"));
+	}
+	async tryAttachToExistingRelay(port) {
+		try {
+			await this.startAsClient(port);
+			process.stderr.write(`[webmcp-local-relay] info: discovered compatible relay on port ${port}, switching to client mode\n`);
+			return true;
+		} catch {
+			return false;
 		}
 	}
 	/**
@@ -675,6 +841,9 @@ var RelayBridgeServer = class extends EventEmitter {
 				pending.reject(/* @__PURE__ */ new Error("Relay client stopped"));
 			}
 			this.clientPendingInvocations.clear();
+			this.clientTools = [];
+			this.clientSources = [];
+			this.clientToolSourceMap = {};
 			if (this.clientSocket) {
 				try {
 					this.clientSocket.close(1e3, "Relay client shutting down");
@@ -691,6 +860,9 @@ var RelayBridgeServer = class extends EventEmitter {
 		} catch (err) {
 			process.stderr.write(`[webmcp-local-relay] warn: error closing socket during shutdown: ${err instanceof Error ? err.message : String(err)}\n`);
 		}
+		for (const intervalId of this.heartbeatIntervalByConnectionId.values()) clearInterval(intervalId);
+		this.heartbeatIntervalByConnectionId.clear();
+		this.lastPongByConnectionId.clear();
 		this.socketByConnectionId.clear();
 		this.relayClientConnectionIds.clear();
 		for (const pending of this.pendingInvocations.values()) {
@@ -731,11 +903,15 @@ var RelayBridgeServer = class extends EventEmitter {
 		if (this._mode === "client") return this.invokeToolViaRelay(toolName, args);
 		return this.invokeToolLocally(toolName, args, options);
 	}
-	async startAsServer() {
+	async startAsServer(port = this.desiredPort) {
 		const wss = await new Promise((resolve, reject) => {
 			const server = new WebSocketServer({
+				handleProtocols: (protocols) => {
+					for (const protocol of protocols) if (SUPPORTED_SUBPROTOCOLS.has(protocol)) return protocol;
+					return false;
+				},
 				host: this.host,
-				port: this.desiredPort,
+				port,
 				maxPayload: this.maxPayloadBytes
 			});
 			const onListening = () => {
@@ -752,6 +928,13 @@ var RelayBridgeServer = class extends EventEmitter {
 		wss.on("connection", (socket) => {
 			const connectionId = randomUUID();
 			this.socketByConnectionId.set(connectionId, socket);
+			try {
+				socket.send(JSON.stringify(this.buildServerHello()));
+			} catch (err) {
+				process.stderr.write(`[webmcp-local-relay] warn: failed to send server hello to connection ${connectionId}: ${err instanceof Error ? err.message : String(err)}\n`);
+				socket.close(1011, "Failed to send server hello");
+				return;
+			}
 			socket.on("message", (raw) => {
 				this.onSocketMessage(connectionId, raw);
 			});
@@ -762,6 +945,7 @@ var RelayBridgeServer = class extends EventEmitter {
 				process.stderr.write(`[webmcp-local-relay] warn: socket error for connection ${connectionId}: ${err.message}\n`);
 				this.onSocketClose(connectionId);
 			});
+			this.startHeartbeat(connectionId);
 		});
 		wss.on("error", (err) => {
 			process.stderr.write(`[webmcp-local-relay] error: WebSocket server error: ${err.message}\n`);
@@ -773,6 +957,19 @@ var RelayBridgeServer = class extends EventEmitter {
 		if (address && typeof address !== "string") this.desiredPort = address.port;
 		this.on("stateChanged", this.onStateChangedPushRelay);
 	}
+	buildServerHello() {
+		return {
+			type: "server-hello",
+			service: "webmcp-local-relay",
+			version: 1,
+			host: this.host,
+			instanceId: this.instanceId,
+			label: this.label,
+			port: this.desiredPort,
+			relayId: this.relayId ?? this.instanceId,
+			workspace: this.workspace
+		};
+	}
 	invokeToolLocally(toolName, args, options) {
 		const resolveOptions = { toolName };
 		if (options.sourceId !== void 0) resolveOptions.sourceId = options.sourceId;
@@ -877,7 +1074,9 @@ var RelayBridgeServer = class extends EventEmitter {
 				pending.resolve(this.normalizeCallToolResult(message.result));
 				break;
 			}
-			case "pong": break;
+			case "pong":
+				this.lastPongByConnectionId.set(connectionId, Date.now());
+				break;
 		}
 	}
 	/**
@@ -959,6 +1158,7 @@ var RelayBridgeServer = class extends EventEmitter {
 	* Handles source disconnection and rejects in-flight calls owned by that source.
 	*/
 	onSocketClose(connectionId) {
+		this.stopHeartbeat(connectionId);
 		this.relayClientConnectionIds.delete(connectionId);
 		this.registry.removeConnection(connectionId);
 		this.socketByConnectionId.delete(connectionId);
@@ -970,72 +1170,126 @@ var RelayBridgeServer = class extends EventEmitter {
 			pending.reject(/* @__PURE__ */ new Error(`Tool source ${connectionId} disconnected during invocation`));
 		}
 	}
-	async startAsClient() {
+	startHeartbeat(connectionId) {
+		this.lastPongByConnectionId.set(connectionId, Date.now());
+		const intervalId = setInterval(() => {
+			const socket = this.socketByConnectionId.get(connectionId);
+			if (!socket || socket.readyState !== WebSocket.OPEN) {
+				this.stopHeartbeat(connectionId);
+				return;
+			}
+			if (this.relayClientConnectionIds.has(connectionId)) return;
+			const lastPong = this.lastPongByConnectionId.get(connectionId) ?? 0;
+			if (Date.now() - lastPong > HEARTBEAT_DEAD_THRESHOLD_MS) {
+				process.stderr.write(`[webmcp-local-relay] warn: connection ${connectionId} missed heartbeat, closing\n`);
+				this.stopHeartbeat(connectionId);
+				socket.close(1001, "Heartbeat timeout");
+				return;
+			}
+			try {
+				socket.send(JSON.stringify({ type: "ping" }));
+			} catch (err) {
+				process.stderr.write(`[webmcp-local-relay] warn: failed to send heartbeat ping to ${connectionId}: ${err instanceof Error ? err.message : String(err)}\n`);
+			}
+		}, HEARTBEAT_INTERVAL_MS);
+		this.heartbeatIntervalByConnectionId.set(connectionId, intervalId);
+	}
+	stopHeartbeat(connectionId) {
+		const intervalId = this.heartbeatIntervalByConnectionId.get(connectionId);
+		if (intervalId !== void 0) {
+			clearInterval(intervalId);
+			this.heartbeatIntervalByConnectionId.delete(connectionId);
+		}
+		this.lastPongByConnectionId.delete(connectionId);
+	}
+	async startAsClient(port = this.desiredPort) {
+		this.stopping = false;
+		const previousMode = this._mode;
+		const previousPort = this.desiredPort;
+		this._mode = "client";
+		this.desiredPort = port;
+		try {
+			const { bufferedMessages, socket } = await this.connectToRelayServer(port);
+			this.clientSocket = socket;
+			this.clientReconnectDelay = 500;
+			this.clientReconnectAttempts = 0;
+			this.setupClientHandlers(socket, bufferedMessages);
+		} catch (error) {
+			this._mode = previousMode;
+			this.desiredPort = previousPort;
+			throw error;
+		}
+	}
+	async connectToRelayServer(port) {
 		this.stopping = false;
 		return new Promise((resolve, reject) => {
-			const ws = new WebSocket(`ws://${this.host}:${this.desiredPort}`);
+			const wsUrl = `ws://${this.host}:${port}`;
+			const ws = new WebSocket(wsUrl, [RELAY_INTERNAL_PROTOCOL, RELAY_BROWSER_PROTOCOL]);
+			const bufferedMessages = [];
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				ws.off("close", onCloseBeforeReady);
+				ws.off("error", onErrorBeforeReady);
+				ws.off("message", onMessageBeforeReady);
+				ws.off("open", onOpen);
+			};
+			const rejectWith = (error) => {
+				ws.once("error", () => {});
+				cleanup();
+				reject(error);
+			};
+			const finish = () => {
+				cleanup();
+				resolve({
+					bufferedMessages,
+					socket: ws
+				});
+			};
 			const onOpen = () => {
-				ws.off("error", onFirstError);
-				this.clientSocket = ws;
-				this.clientReconnectDelay = 500;
 				try {
-					ws.send(JSON.stringify({ type: "relay/hello" }));
-					ws.send(JSON.stringify({ type: "relay/list-tools" }));
+					this.sendRelayClientHandshake(ws);
 				} catch (err) {
-					process.stderr.write(`[webmcp-local-relay] error: failed to send handshake to relay server: ${err instanceof Error ? err.message : String(err)}\n`);
-					this.clientSocket = null;
-					ws.close();
-					reject(/* @__PURE__ */ new Error("Failed to send handshake to relay server"));
-					return;
+					rejectWith(/* @__PURE__ */ new Error(`Failed to send handshake to relay server at ${wsUrl}: ${err instanceof Error ? err.message : String(err)}`));
 				}
-				this.setupClientHandlers(ws);
-				resolve();
 			};
-			const onFirstError = (err) => {
-				ws.off("open", onOpen);
-				reject(/* @__PURE__ */ new Error(`Failed to connect to relay server at ws://${this.host}:${this.desiredPort}: ${err.message}`));
+			const onErrorBeforeReady = (err) => {
+				rejectWith(/* @__PURE__ */ new Error(`Failed to connect to relay server at ${wsUrl}: ${err.message}`));
+			};
+			const onCloseBeforeReady = () => {
+				rejectWith(/* @__PURE__ */ new Error(`Connection to ${wsUrl} closed before relay verification completed`));
+			};
+			const onMessageBeforeReady = (raw) => {
+				const message = this.parseRelayServerMessage(raw);
+				if (!message) {
+					rejectWith(/* @__PURE__ */ new Error(`Received a non-relay response while probing ${wsUrl}`));
+					return;
+				}
+				bufferedMessages.push(message);
+				if (message.type === "server-hello") {
+					if (message.service !== "webmcp-local-relay") {
+						rejectWith(/* @__PURE__ */ new Error(`Unexpected relay service "${message.service}" at ${wsUrl}`));
+						return;
+					}
+					finish();
+					return;
+				}
+				if (message.type === "relay/tools" || message.type === "relay/tools-changed") finish();
 			};
+			const timeoutId = setTimeout(() => {
+				rejectWith(/* @__PURE__ */ new Error(`Timed out waiting for relay hello from ${wsUrl}`));
+			}, RELAY_SERVER_MESSAGE_TIMEOUT_MS);
 			ws.once("open", onOpen);
-			ws.once("error", onFirstError);
+			ws.once("error", onErrorBeforeReady);
+			ws.once("close", onCloseBeforeReady);
+			ws.on("message", onMessageBeforeReady);
 		});
 	}
-	setupClientHandlers(ws) {
+	setupClientHandlers(ws, bufferedMessages = []) {
+		for (const message of bufferedMessages) this.processRelayServerMessage(message);
 		ws.on("message", (raw) => {
-			const text = this.rawDataToUtf8(raw);
-			let parsed;
-			try {
-				parsed = JSON.parse(text);
-			} catch (err) {
-				const preview = text.length > 200 ? `${text.slice(0, 200)}...` : text;
-				process.stderr.write(`[webmcp-local-relay] warn: invalid JSON from relay server (${err instanceof Error ? err.message : "parse error"}): ${preview}\n`);
-				return;
-			}
-			const msg = RelayServerToClientMessageSchema.safeParse(parsed);
-			if (!msg.success) {
-				const typeField = typeof parsed === "object" && parsed !== null ? parsed.type : "unknown";
-				process.stderr.write(`[webmcp-local-relay] warn: invalid relay server message (type=${typeField}): ${msg.error.message}\n`);
-				return;
-			}
-			switch (msg.data.type) {
-				case "relay/tools":
-				case "relay/tools-changed":
-					this.clientTools = msg.data.tools;
-					this.clientSources = msg.data.sources;
-					this.clientToolSourceMap = msg.data.toolSourceMap;
-					this.emit("stateChanged");
-					break;
-				case "relay/result": {
-					const pending = this.clientPendingInvocations.get(msg.data.callId);
-					if (!pending) {
-						process.stderr.write(`[webmcp-local-relay] warn: received relay result for unknown callId ${msg.data.callId}\n`);
-						break;
-					}
-					clearTimeout(pending.timeoutId);
-					this.clientPendingInvocations.delete(msg.data.callId);
-					pending.resolve(msg.data.result);
-					break;
-				}
-			}
+			const message = this.parseRelayServerMessage(raw);
+			if (!message) return;
+			this.processRelayServerMessage(message);
 		});
 		ws.on("close", () => {
 			this.clientSocket = null;
@@ -1054,6 +1308,51 @@ var RelayBridgeServer = class extends EventEmitter {
 			process.stderr.write(`[webmcp-local-relay] warn: relay client socket error: ${err.message}\n`);
 		});
 	}
+	sendRelayClientHandshake(ws) {
+		ws.send(JSON.stringify({ type: "relay/hello" }));
+		ws.send(JSON.stringify({ type: "relay/list-tools" }));
+	}
+	parseRelayServerMessage(raw) {
+		const text = this.rawDataToUtf8(raw);
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch (err) {
+			const preview = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+			process.stderr.write(`[webmcp-local-relay] warn: invalid JSON from relay server (${err instanceof Error ? err.message : "parse error"}): ${preview}\n`);
+			return null;
+		}
+		const message = RelayServerToClientMessageSchema.safeParse(parsed);
+		if (!message.success) {
+			const typeField = typeof parsed === "object" && parsed !== null ? parsed.type : "unknown";
+			process.stderr.write(`[webmcp-local-relay] warn: invalid relay server message (type=${typeField}): ${message.error.message}\n`);
+			return null;
+		}
+		return message.data;
+	}
+	processRelayServerMessage(message) {
+		switch (message.type) {
+			case "server-hello": break;
+			case "relay/tools":
+			case "relay/tools-changed":
+				this.clientTools = message.tools;
+				this.clientSources = message.sources;
+				this.clientToolSourceMap = message.toolSourceMap;
+				this.emit("stateChanged");
+				break;
+			case "relay/result": {
+				const pending = this.clientPendingInvocations.get(message.callId);
+				if (!pending) {
+					process.stderr.write(`[webmcp-local-relay] warn: received relay result for unknown callId ${message.callId}\n`);
+					break;
+				}
+				clearTimeout(pending.timeoutId);
+				this.clientPendingInvocations.delete(message.callId);
+				pending.resolve(message.result);
+				break;
+			}
+		}
+	}
 	scheduleReconnect() {
 		if (this.clientReconnectTimer || this.stopping) return;
 		this.clientReconnectAttempts++;
@@ -1074,55 +1373,19 @@ var RelayBridgeServer = class extends EventEmitter {
 	}
 	/**
 	* Attempts to promote from client to server mode when reconnecting.
-	* Tries to bind the port first; if EADDRINUSE, falls back to client mode.
+	* Re-runs the same attach-or-bind strategy used during startup.
 	*/
 	async reconnectWithModePromotion() {
 		try {
-			await this.startAsServer();
-			this._mode = "server";
+			await this.startUsingPortStrategy();
 			this.clientReconnectDelay = 500;
 			this.clientReconnectAttempts = 0;
-			process.stderr.write("[webmcp-local-relay] info: promoted from client to server mode\n");
-			this.emit("stateChanged");
-		} catch (err) {
-			if (!(err instanceof Error && ("code" in err ? err.code === "EADDRINUSE" : err.message.includes("EADDRINUSE")))) {
-				process.stderr.write(`[webmcp-local-relay] warn: server promotion failed: ${err instanceof Error ? err.message : String(err)}\n`);
-				if (!this.stopping) this.scheduleReconnect();
-				return;
+			if (this._mode === "server") {
+				process.stderr.write("[webmcp-local-relay] info: promoted from client to server mode\n");
+				this.emit("stateChanged");
 			}
-			this.reconnectAsClient();
-		}
-	}
-	/**
-	* Reconnects as a client to an existing relay server.
-	*/
-	reconnectAsClient() {
-		try {
-			const ws = new WebSocket(`ws://${this.host}:${this.desiredPort}`);
-			const onReconnectError = (err) => {
-				process.stderr.write(`[webmcp-local-relay] warn: relay client reconnection failed: ${err.message}\n`);
-				if (!this.stopping) this.scheduleReconnect();
-			};
-			ws.once("open", () => {
-				ws.off("error", onReconnectError);
-				this.clientSocket = ws;
-				this.clientReconnectDelay = 500;
-				this.clientReconnectAttempts = 0;
-				try {
-					ws.send(JSON.stringify({ type: "relay/hello" }));
-					ws.send(JSON.stringify({ type: "relay/list-tools" }));
-				} catch (err) {
-					process.stderr.write(`[webmcp-local-relay] error: failed to send handshake during reconnection: ${err instanceof Error ? err.message : String(err)}\n`);
-					this.clientSocket = null;
-					ws.close();
-					this.scheduleReconnect();
-					return;
-				}
-				this.setupClientHandlers(ws);
-			});
-			ws.once("error", onReconnectError);
 		} catch (err) {
-			process.stderr.write(`[webmcp-local-relay] error: failed to create reconnection socket: ${err instanceof Error ? err.message : String(err)}\n`);
+			process.stderr.write(`[webmcp-local-relay] warn: reconnection failed: ${err instanceof Error ? err.message : String(err)}\n`);
 			if (!this.stopping) this.scheduleReconnect();
 		}
 	}
@@ -1212,6 +1475,37 @@ var RelayBridgeServer = class extends EventEmitter {
 	}
 };
 
+//#endregion
+//#region src/staticToolSchemas.ts
+const EMPTY_STATIC_TOOL_INPUT_SHAPE = {};
+const WEBMCP_CALL_TOOL_INPUT_SHAPE = {
+	name: z.string().describe("The tool name to call. Use webmcp_list_tools to see available tool names."),
+	arguments: z.record(z.string(), z.unknown()).optional().describe("Arguments to pass to the tool as a JSON object. Check the tool inputSchema from webmcp_list_tools for expected fields.")
+};
+const WEBMCP_OPEN_PAGE_INPUT_SHAPE = {
+	url: z.string().describe("URL to open or match for refresh."),
+	refresh: z.boolean().optional().describe("If true, refresh the connected source matching this URL instead of opening a new tab.")
+};
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stripJsonSchemaMetadata(value) {
+	if (Array.isArray(value)) return value.map((item) => stripJsonSchemaMetadata(item));
+	if (!isRecord(value)) return value;
+	const next = {};
+	for (const [key, nestedValue] of Object.entries(value)) {
+		if (key === "$schema") continue;
+		next[key] = stripJsonSchemaMetadata(nestedValue);
+	}
+	return next;
+}
+function publicInputSchemaFromZodShape(inputShape) {
+	return stripJsonSchemaMetadata(toJsonSchemaCompat(z.object(inputShape), {
+		strictUnions: true,
+		pipeStrategy: "input"
+	}));
+}
+
 //#endregion
 //#region src/mcpRelayServer.ts
 /**
@@ -1223,7 +1517,9 @@ var LocalRelayMcpServer = class {
 	*/
 	bridge;
 	mcpServer;
+	staticToolData = /* @__PURE__ */ new Map();
 	dynamicToolHandles = /* @__PURE__ */ new Map();
+	dynamicToolData = /* @__PURE__ */ new Map();
 	dynamicToolSignature = /* @__PURE__ */ new Map();
 	syncing = false;
 	syncRequested = false;
@@ -1243,6 +1539,7 @@ var LocalRelayMcpServer = class {
 			});
 		});
 		this.registerStaticTools();
+		this.overrideListToolsHandler();
 	}
 	/**
 	* Starts the browser bridge and synchronizes dynamic MCP tools.
@@ -1289,210 +1586,246 @@ var LocalRelayMcpServer = class {
 		return Array.from(this.dynamicToolHandles.keys()).sort();
 	}
 	/**
+	* Overrides the SDK's ListTools handler to return real JSON Schema
+	* for dynamic tools instead of the empty `z.object({}).passthrough()`
+	* schema that the SDK would otherwise convert to `{ type: 'object' }`.
+	*
+	* The MCP SDK's McpServer internally runs `toJsonSchemaCompat()` on
+	* registered inputSchema values, which strips plain JSON Schema objects
+	* (non-Zod) to empty schemas. This override bypasses that conversion
+	* for dynamic (relayed) tools while preserving static tools as-is.
+	*/
+	overrideListToolsHandler() {
+		this.mcpServer.server.setRequestHandler(ListToolsRequestSchema, () => {
+			return { tools: [...Array.from(this.staticToolData.values()).map((tool) => ({ ...tool })), ...Array.from(this.dynamicToolData.entries()).map(([name, tool]) => ({
+				name,
+				description: this.dynamicToolDescription(tool),
+				inputSchema: tool.inputSchema,
+				...tool.outputSchema ? { outputSchema: tool.outputSchema } : {},
+				...tool.annotations ? { annotations: tool.annotations } : {}
+			}))].sort((left, right) => String(left.name).localeCompare(String(right.name))) };
+		});
+	}
+	registerStaticTool({ name, description, inputShape, annotations, handler }) {
+		this.mcpServer.registerTool(name, {
+			description,
+			inputSchema: inputShape,
+			...annotations ? { annotations } : {}
+		}, handler);
+		this.staticToolData.set(name, {
+			name,
+			description,
+			inputSchema: publicInputSchemaFromZodShape(inputShape),
+			...annotations ? { annotations } : {}
+		});
+	}
+	/**
 	* Registers built-in management tools exposed by the relay.
 	*/
 	registerStaticTools() {
-		this.mcpServer.registerTool("webmcp_list_sources", {
+		this.registerStaticTool({
+			name: "webmcp_list_sources",
 			description: "List connected browser tool sources and their metadata.",
-			inputSchema: {},
+			inputShape: EMPTY_STATIC_TOOL_INPUT_SHAPE,
 			annotations: {
 				readOnlyHint: true,
 				idempotentHint: true
-			}
-		}, async () => {
-			if (this.bridge.mode === "client") {
-				const sources$1 = this.bridge.listSourcesFromRelay();
-				const info = {
-					mode: "client",
-					count: sources$1.length,
-					sources: sources$1
-				};
+			},
+			handler: async () => {
+				if (this.bridge.mode === "client") {
+					const sources$1 = this.bridge.listSourcesFromRelay();
+					const info = {
+						mode: "client",
+						count: sources$1.length,
+						sources: sources$1
+					};
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify(info, null, 2)
+						}],
+						structuredContent: info
+					};
+				}
+				const sources = this.bridge.registry.listSources();
 				return {
 					content: [{
 						type: "text",
-						text: JSON.stringify(info, null, 2)
+						text: JSON.stringify({
+							count: sources.length,
+							sources
+						}, null, 2)
 					}],
-					structuredContent: info
-				};
-			}
-			const sources = this.bridge.registry.listSources();
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify({
+					structuredContent: {
 						count: sources.length,
 						sources
-					}, null, 2)
-				}],
-				structuredContent: {
-					count: sources.length,
-					sources
-				}
-			};
+					}
+				};
+			}
 		});
-		this.mcpServer.registerTool("webmcp_list_tools", {
+		this.registerStaticTool({
+			name: "webmcp_list_tools",
 			description: "List WebMCP tools available from connected browser sources. Returns tool definitions including name, description, input schema, and source info. Use webmcp_call_tool to invoke a tool by name.",
-			inputSchema: {},
+			inputShape: EMPTY_STATIC_TOOL_INPUT_SHAPE,
 			annotations: {
 				readOnlyHint: true,
 				idempotentHint: true
-			}
-		}, async () => {
-			const tools = this.listAggregatedTools();
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify({
-						count: tools.length,
-						tools
-					}, null, 2)
-				}],
-				structuredContent: {
-					count: tools.length,
-					tools
-				}
-			};
-		});
-		this.mcpServer.registerTool("webmcp_call_tool", {
-			description: "Call a WebMCP tool registered by a connected browser page. Use webmcp_list_tools first to see available tools and their input schemas.",
-			inputSchema: {
-				name: z.string().describe("The tool name to call. Use webmcp_list_tools to see available tool names."),
-				arguments: z.record(z.string(), z.unknown()).optional().describe("Arguments to pass to the tool as a JSON object. Check the tool inputSchema from webmcp_list_tools for expected fields.")
 			},
-			annotations: { readOnlyHint: false }
-		}, async ({ name, arguments: args }) => {
-			const tools = this.listAggregatedTools();
-			const toolSummary = this.buildToolSummary(tools);
-			if (!tools.find((t) => t.name === name)) {
-				const errorLines = [`Tool "${name}" not found.`];
-				if (toolSummary) errorLines.push("", "Available tools:", toolSummary);
-				else errorLines.push("", "No tools are currently available. Ensure a browser page with WebMCP is connected.");
+			handler: async () => {
+				const tools = this.listAggregatedTools();
 				return {
 					content: [{
 						type: "text",
-						text: errorLines.join("\n")
+						text: JSON.stringify({
+							count: tools.length,
+							tools
+						}, null, 2)
 					}],
-					isError: true
+					structuredContent: {
+						count: tools.length,
+						tools
+					}
 				};
 			}
-			try {
-				const result = await this.bridge.invokeTool(name, args ?? {});
-				const updatedTools = this.bridge.mode === "client" ? this.buildAggregatedToolsFromRelay() : this.bridge.registry.listTools();
-				const updatedSummary = this.buildToolSummary(updatedTools);
-				if (updatedSummary) result.content = [...result.content, {
-					type: "text",
-					text: `\n---\nAvailable tools:\n${updatedSummary}`
-				}];
-				return result;
-			} catch (err) {
-				const errorLines = [`Failed to call tool "${name}": ${err instanceof Error ? err.message : String(err)}`];
-				if (toolSummary) errorLines.push("", "Available tools:", toolSummary);
-				return {
-					content: [{
+		});
+		this.registerStaticTool({
+			name: "webmcp_call_tool",
+			description: "Call a WebMCP tool registered by a connected browser page. Use webmcp_list_tools first to see available tools and their input schemas.",
+			inputShape: WEBMCP_CALL_TOOL_INPUT_SHAPE,
+			annotations: { readOnlyHint: false },
+			handler: async ({ name, arguments: args }) => {
+				const tools = this.listAggregatedTools();
+				const toolSummary = this.buildToolSummary(tools);
+				if (!tools.find((t) => t.name === name)) {
+					const errorLines = [`Tool "${name}" not found.`];
+					if (toolSummary) errorLines.push("", "Available tools:", toolSummary);
+					else errorLines.push("", "No tools are currently available. Ensure a browser page with WebMCP is connected.");
+					return {
+						content: [{
+							type: "text",
+							text: errorLines.join("\n")
+						}],
+						isError: true
+					};
+				}
+				try {
+					const result = await this.bridge.invokeTool(name, args ?? {});
+					const updatedTools = this.bridge.mode === "client" ? this.buildAggregatedToolsFromRelay() : this.bridge.registry.listTools();
+					const updatedSummary = this.buildToolSummary(updatedTools);
+					if (updatedSummary) result.content = [...result.content, {
 						type: "text",
-						text: errorLines.join("\n")
-					}],
-					isError: true
-				};
+						text: `\n---\nAvailable tools:\n${updatedSummary}`
+					}];
+					return result;
+				} catch (err) {
+					const errorLines = [`Failed to call tool "${name}": ${err instanceof Error ? err.message : String(err)}`];
+					if (toolSummary) errorLines.push("", "Available tools:", toolSummary);
+					return {
+						content: [{
+							type: "text",
+							text: errorLines.join("\n")
+						}],
+						isError: true
+					};
+				}
 			}
 		});
-		this.mcpServer.registerTool("webmcp_open_page", {
+		this.registerStaticTool({
+			name: "webmcp_open_page",
 			description: "Open a URL in the user's default browser, or refresh a connected source page. Use to launch WebMCP-enabled pages or reload stale connections.",
-			inputSchema: {
-				url: z.string().describe("URL to open or match for refresh."),
-				refresh: z.boolean().optional().describe("If true, refresh the connected source matching this URL instead of opening a new tab.")
-			},
-			annotations: { readOnlyHint: false }
-		}, async ({ url, refresh }) => {
-			let parsed;
-			try {
-				parsed = new URL(url);
-			} catch {
-				return {
-					content: [{
-						type: "text",
-						text: `Invalid URL: ${url}`
-					}],
-					isError: true
-				};
-			}
-			if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
-				content: [{
-					type: "text",
-					text: `Only http: and https: URLs are allowed. Got: ${parsed.protocol}`
-				}],
-				isError: true
-			};
-			if (refresh) {
-				if (this.bridge.mode === "client") return {
+			inputShape: WEBMCP_OPEN_PAGE_INPUT_SHAPE,
+			annotations: { readOnlyHint: false },
+			handler: async ({ url, refresh }) => {
+				let parsed;
+				try {
+					parsed = new URL(url);
+				} catch {
+					return {
+						content: [{
+							type: "text",
+							text: `Invalid URL: ${url}`
+						}],
+						isError: true
+					};
+				}
+				if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
 					content: [{
 						type: "text",
-						text: "Refresh is not supported in client mode. Only the server relay can reload sources."
+						text: `Only http: and https: URLs are allowed. Got: ${parsed.protocol}`
 					}],
 					isError: true
 				};
-				const matched = this.bridge.registry.listSources().find((s) => {
-					if (!s.url) return false;
+				if (refresh) {
+					if (this.bridge.mode === "client") return {
+						content: [{
+							type: "text",
+							text: "Refresh is not supported in client mode. Only the server relay can reload sources."
+						}],
+						isError: true
+					};
+					const matched = this.bridge.registry.listSources().find((s) => {
+						if (!s.url) return false;
+						try {
+							return new URL(s.url).origin === parsed.origin;
+						} catch {
+							process.stderr.write(`[webmcp-local-relay] warn: source ${s.sourceId} has unparseable URL: ${s.url}\n`);
+							return false;
+						}
+					});
+					if (!matched) return {
+						content: [{
+							type: "text",
+							text: `No connected source matches origin ${parsed.origin}. The page may not be open or connected.`
+						}],
+						isError: true
+					};
 					try {
-						return new URL(s.url).origin === parsed.origin;
-					} catch {
-						process.stderr.write(`[webmcp-local-relay] warn: source ${s.sourceId} has unparseable URL: ${s.url}\n`);
-						return false;
+						this.bridge.reloadSource(matched.sourceId);
+						return { content: [{
+							type: "text",
+							text: `Reload sent to source ${matched.sourceId} (${matched.url ?? matched.origin}).`
+						}] };
+					} catch (err) {
+						return {
+							content: [{
+								type: "text",
+								text: `Failed to reload source: ${err instanceof Error ? err.message : String(err)}`
+							}],
+							isError: true
+						};
 					}
-				});
-				if (!matched) return {
-					content: [{
-						type: "text",
-						text: `No connected source matches origin ${parsed.origin}. The page may not be open or connected.`
-					}],
-					isError: true
-				};
+				}
 				try {
-					this.bridge.reloadSource(matched.sourceId);
-					return { content: [{
-						type: "text",
-						text: `Reload sent to source ${matched.sourceId} (${matched.url ?? matched.origin}).`
-					}] };
+					await this.openInBrowser(url);
 				} catch (err) {
 					return {
 						content: [{
 							type: "text",
-							text: `Failed to reload source: ${err instanceof Error ? err.message : String(err)}`
+							text: `Failed to open browser: ${err instanceof Error ? err.message : String(err)}`
 						}],
 						isError: true
 					};
 				}
-			}
-			try {
-				await this.openInBrowser(url);
-			} catch (err) {
-				return {
-					content: [{
+				if (this.bridge.mode === "server") {
+					const existing = this.bridge.registry.listSources().find((s) => {
+						if (!s.url) return false;
+						try {
+							return new URL(s.url).origin === parsed.origin;
+						} catch {
+							process.stderr.write(`[webmcp-local-relay] warn: source ${s.sourceId} has unparseable URL: ${s.url}\n`);
+							return false;
+						}
+					});
+					if (existing) return { content: [{
 						type: "text",
-						text: `Failed to open browser: ${err instanceof Error ? err.message : String(err)}`
-					}],
-					isError: true
-				};
-			}
-			if (this.bridge.mode === "server") {
-				const existing = this.bridge.registry.listSources().find((s) => {
-					if (!s.url) return false;
-					try {
-						return new URL(s.url).origin === parsed.origin;
-					} catch {
-						process.stderr.write(`[webmcp-local-relay] warn: source ${s.sourceId} has unparseable URL: ${s.url}\n`);
-						return false;
-					}
-				});
-				if (existing) return { content: [{
+						text: `Opened ${url} in the default browser. Note: a source from ${existing.url ?? existing.origin} is already connected.`
+					}] };
+				}
+				return { content: [{
 					type: "text",
-					text: `Opened ${url} in the default browser. Note: a source from ${existing.url ?? existing.origin} is already connected.`
+					text: `Opened ${url} in the default browser.`
 				}] };
 			}
-			return { content: [{
-				type: "text",
-				text: `Opened ${url} in the default browser.`
-			}] };
 		});
 	}
 	/**
@@ -1601,6 +1934,7 @@ var LocalRelayMcpServer = class {
 			if (nextNames.has(name)) continue;
 			handle.remove();
 			this.dynamicToolHandles.delete(name);
+			this.dynamicToolData.delete(name);
 			this.dynamicToolSignature.delete(name);
 			changed = true;
 		}
@@ -1614,6 +1948,7 @@ var LocalRelayMcpServer = class {
 			}
 			const handle = this.registerDynamicTool(tool);
 			this.dynamicToolHandles.set(tool.name, handle);
+			this.dynamicToolData.set(tool.name, tool);
 			this.dynamicToolSignature.set(tool.name, signature);
 			changed = true;
 		}
@@ -1694,5 +2029,5 @@ var LocalRelayMcpServer = class {
 };
 
 //#endregion
-export { printHelp as C, parseCliOptions as S, NormalizedToolSchema as _, RelayServerToClientMessageSchema as a, ToolSchema as b, HelloRequiredError as c, extractSanitizedDomain as d, sanitizeName as f, InboundToolSchema as g, DEFAULT_TOOL_INPUT_SCHEMA as h, RelayClientToServerMessageSchema as i, RelayRegistry as l, CallToolResultSchema as m, RelayBridgeServer as n, RelaySourceInfoSchema as o, CallToolRequestParamsSchema as p, BrowserToRelayMessageSchema as r, RelayToBrowserMessageSchema as s, LocalRelayMcpServer as t, buildPublicToolName as u, RelayInvokeArgsSchema as v, normalizeInboundTool as x, ToolAnnotationsSchema as y };
-//# sourceMappingURL=mcpRelayServer-DAp7h9b1.js.map
+export { normalizeInboundTool as C, ToolSchema as S, printHelp as T, DEFAULT_TOOL_INPUT_SCHEMA as _, RelayDescriptorSchema as a, RelayInvokeArgsSchema as b, RelayToBrowserMessageSchema as c, RelayRegistry as d, buildPublicToolName as f, CallToolResultSchema as g, CallToolRequestParamsSchema as h, RelayClientToServerMessageSchema as i, ServerHelloMessageSchema as l, sanitizeName as m, RelayBridgeServer as n, RelayServerToClientMessageSchema as o, extractSanitizedDomain as p, BrowserToRelayMessageSchema as r, RelaySourceInfoSchema as s, LocalRelayMcpServer as t, HelloRequiredError as u, InboundToolSchema as v, parseCliOptions as w, ToolAnnotationsSchema as x, NormalizedToolSchema as y };
+//# sourceMappingURL=mcpRelayServer-rbay_DSr.js.map