@mcp-b/webmcp-local-relay 4.0.0 → 5.0.0

package/dist/{mcpRelayServer-BT1ct1Cc.mjs → mcpRelayServer-BxI6zEc2.mjs}

@@ -4,12 +4,12 @@ import WebSocket, { WebSocketServer } from "ws";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { CallToolRequestParamsSchema, CallToolResultSchema, ListToolsRequestSchema, ToolAnnotationsSchema, ToolSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestParamsSchema, CallToolResultSchema, ToolAnnotationsSchema, ToolSchema } from "@modelcontextprotocol/core";
 import { z } from "zod/v4";
+import { parseArgs } from "node:util";
 import { execFile } from "node:child_process";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+import { McpServer, fromJsonSchema } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 
 //#region src/portStrategy.ts
 const DEFAULT_RELAY_PORT = 9333;
@@ -34,7 +34,7 @@ async function readPersistedPort(path = defaultRelayPortPersistPath(), options =
 		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 ?? 864e5;
+		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;
@@ -75,13 +75,6 @@ async function buildPortCandidates(options) {
 */
 const NormalizedToolSchema = ToolSchema.extend({ name: ToolSchema.shape.name.min(1) });
 /**
-* Permissive inbound tool shape from browser/widget payloads.
-*
-* Only enforces a non-empty name at ingest. All other fields are normalized
-* against SDK schemas by {@link normalizeInboundTool}.
-*/
-const InboundToolSchema = z.object({ name: z.string().min(1) }).passthrough();
-/**
 * SDK-derived argument schema for tool invocation payloads.
 */
 const RelayInvokeArgsSchema = CallToolRequestParamsSchema.shape.arguments;
@@ -93,30 +86,16 @@ const DEFAULT_TOOL_INPUT_SCHEMA = {
 	type: "object",
 	properties: {}
 };
+/** SDK tool schema with a browser-compatible default input schema. */
+const InboundToolSchema = NormalizedToolSchema.extend({ inputSchema: NormalizedToolSchema.shape.inputSchema.optional() });
 /**
-* Normalizes permissive inbound tool payloads into SDK-compliant Tool objects.
-*
-* Invalid optional metadata (description, output schema, annotations, etc.)
-* is dropped. Invalid/missing inputSchema falls back to an empty object schema.
+* Applies the browser default input schema and validates the complete SDK tool.
 */
 function normalizeInboundTool(inbound) {
-	const inputSchemaParsed = ToolSchema.shape.inputSchema.safeParse(inbound.inputSchema);
-	const outputSchemaParsed = ToolSchema.shape.outputSchema.safeParse(inbound.outputSchema);
-	const annotationsParsed = ToolAnnotationsSchema.safeParse(inbound.annotations);
-	const normalizedCandidate = {
-		name: inbound.name,
-		inputSchema: inputSchemaParsed.success ? inputSchemaParsed.data : DEFAULT_TOOL_INPUT_SCHEMA
-	};
-	if (typeof inbound.description === "string") normalizedCandidate.description = inbound.description;
-	if (typeof inbound.title === "string") normalizedCandidate.title = inbound.title;
-	if (outputSchemaParsed.success && outputSchemaParsed.data !== void 0) normalizedCandidate.outputSchema = outputSchemaParsed.data;
-	if (annotationsParsed.success && annotationsParsed.data !== void 0) normalizedCandidate.annotations = annotationsParsed.data;
-	const normalizedParsed = NormalizedToolSchema.safeParse(normalizedCandidate);
-	if (normalizedParsed.success) return normalizedParsed.data;
-	return {
-		name: inbound.name,
-		inputSchema: DEFAULT_TOOL_INPUT_SCHEMA
-	};
+	return NormalizedToolSchema.parse({
+		...inbound,
+		inputSchema: inbound.inputSchema ?? DEFAULT_TOOL_INPUT_SCHEMA
+	});
 }
 
 //#endregion
@@ -156,12 +135,10 @@ function extractSanitizedDomain(originOrUrl) {
 */
 function buildPublicToolName(options) {
 	const safeName = sanitizeName(options.originalToolName);
-	if (!options.disambiguate || !options.tabId) return safeName.slice(0, MAX_MCP_TOOL_NAME_LENGTH);
+	if (!options.disambiguate || !options.tabId) return safeName.slice(0, 128);
 	const suffix = `_${sanitizeName(options.tabId).slice(0, TAB_ID_DISAMBIGUATION_LENGTH)}`;
-	const base = `${safeName}${suffix}`;
-	if (base.length <= MAX_MCP_TOOL_NAME_LENGTH) return base;
-	const available = MAX_MCP_TOOL_NAME_LENGTH - suffix.length;
-	return `${safeName.slice(0, Math.max(1, available))}${suffix}`;
+	const available = 128 - suffix.length;
+	return `${safeName.slice(0, available)}${suffix}`;
 }
 
 //#endregion
@@ -217,7 +194,6 @@ var RelayRegistry = class {
 		const source = this.sourceByConnectionId.get(connectionId);
 		if (!source) throw new HelloRequiredError(connectionId);
 		this.touchConnection(connectionId);
-		this.removeConnectionTools(connectionId);
 		const providers = tools.map((tool) => ({
 			sourceId: connectionId,
 			tabId: source.tabId,
@@ -231,7 +207,7 @@ var RelayRegistry = class {
 	* Removes a source and all of its tool registrations.
 	*/
 	removeConnection(connectionId) {
-		this.removeConnectionTools(connectionId);
+		this.toolsByConnectionId.delete(connectionId);
 		this.sourceByConnectionId.delete(connectionId);
 		this.rebuildPublicNames();
 	}
@@ -283,31 +259,10 @@ var RelayRegistry = class {
 		const providers = this.providersByPublicToolName.get(options.toolName);
 		if (!providers || providers.length === 0) return null;
 		const rankedProviders = this.sortProvidersByRecency(providers);
-		if (options.sourceId) {
-			const byConnection = rankedProviders.find((provider) => provider.sourceId === options.sourceId);
-			if (byConnection) return {
-				connectionId: byConnection.sourceId,
-				tool: byConnection.tool,
-				publicToolName: byConnection.publicToolName
-			};
-			const byTabId = rankedProviders.find((provider) => provider.tabId === options.sourceId);
-			if (byTabId) return {
-				connectionId: byTabId.sourceId,
-				tool: byTabId.tool,
-				publicToolName: byTabId.publicToolName
-			};
-			return null;
-		}
-		if (options.requestTabId) {
-			const byRequestTab = rankedProviders.find((provider) => provider.tabId === options.requestTabId);
-			if (!byRequestTab) return null;
-			return {
-				connectionId: byRequestTab.sourceId,
-				tool: byRequestTab.tool,
-				publicToolName: byRequestTab.publicToolName
-			};
-		}
-		const provider = rankedProviders[0];
+		let provider;
+		if (options.sourceId) provider = rankedProviders.find((candidate) => candidate.sourceId === options.sourceId) ?? rankedProviders.find((candidate) => candidate.tabId === options.sourceId);
+		else if (options.requestTabId) provider = rankedProviders.find((candidate) => candidate.tabId === options.requestTabId);
+		else provider = rankedProviders[0];
 		if (!provider) return null;
 		return {
 			connectionId: provider.sourceId,
@@ -325,12 +280,6 @@ var RelayRegistry = class {
 		};
 	}
 	/**
-	* Removes all tool providers for a connection.
-	*/
-	removeConnectionTools(connectionId) {
-		this.toolsByConnectionId.delete(connectionId);
-	}
-	/**
 	* Rebuilds public tool names after source set changes.
 	*
 	* When the same original tool name appears in multiple tabs, names are
@@ -345,18 +294,36 @@ var RelayRegistry = class {
 			byOriginalName.set(key, group);
 		}
 		this.providersByPublicToolName.clear();
-		for (const [, providers] of byOriginalName) {
+		const allocations = [];
+		for (const [originalName, providers] of byOriginalName) {
 			const disambiguate = new Set(providers.map((p) => p.tabId)).size > 1;
-			for (const provider of providers) {
-				provider.publicToolName = buildPublicToolName({
-					originalToolName: provider.tool.name,
+			for (const provider of providers) allocations.push({
+				candidate: buildPublicToolName({
+					originalToolName: originalName,
 					tabId: provider.tabId,
 					disambiguate
-				});
-				const existing = this.providersByPublicToolName.get(provider.publicToolName) ?? [];
-				existing.push(provider);
-				this.providersByPublicToolName.set(provider.publicToolName, this.sortProvidersByRecency(existing));
+				}),
+				key: disambiguate ? `${originalName}\0${provider.tabId}` : originalName,
+				provider
+			});
+		}
+		const nameByKey = /* @__PURE__ */ new Map();
+		const usedNames = /* @__PURE__ */ new Set();
+		for (const { candidate, key, provider } of allocations.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0)) {
+			let publicToolName = nameByKey.get(key);
+			if (!publicToolName) {
+				publicToolName = candidate;
+				for (let index = 2; usedNames.has(publicToolName); index += 1) {
+					const suffix = `_${String(index)}`;
+					publicToolName = `${candidate.slice(0, 128 - suffix.length)}${suffix}`;
+				}
+				nameByKey.set(key, publicToolName);
+				usedNames.add(publicToolName);
 			}
+			provider.publicToolName = publicToolName;
+			const existing = this.providersByPublicToolName.get(publicToolName) ?? [];
+			existing.push(provider);
+			this.providersByPublicToolName.set(publicToolName, existing);
 		}
 	}
 	/**
@@ -383,9 +350,9 @@ var RelayRegistry = class {
 
 //#endregion
 //#region src/schemas.ts
-/**
-* Schema for source identity bootstrap message.
-*/
+function normalizeSupportedInboundTools(tools) {
+	return tools.map(normalizeInboundTool).filter((tool) => tool.execution?.taskSupport !== "required");
+}
 const BrowserHelloMessageSchema = z.object({
 	type: z.literal("hello"),
 	tabId: z.string().min(1),
@@ -394,56 +361,21 @@ const BrowserHelloMessageSchema = z.object({
 	title: z.string().optional(),
 	iconUrl: z.string().optional()
 });
-/**
-* Schema for full tool-list synchronization message.
-*
-* Inbound tools are permissively parsed then normalized to SDK Tool shape.
-*/
 const BrowserToolsListMessageSchema = z.object({
 	type: z.literal("tools/list"),
-	tools: z.array(InboundToolSchema).transform((tools) => tools.map(normalizeInboundTool))
+	tools: z.array(InboundToolSchema).transform(normalizeSupportedInboundTools)
 });
-/**
-* Schema for tool-set replacement notification pushed after initial registration.
-*
-* Processing is identical to `tools/list` — the full tool set replaces any
-* previously registered tools — but the distinct type signals a dynamic update
-* rather than an initial handshake.
-*/
 const BrowserToolsChangedMessageSchema = z.object({
 	type: z.literal("tools/changed"),
-	tools: z.array(InboundToolSchema).transform((tools) => tools.map(normalizeInboundTool))
+	tools: z.array(InboundToolSchema).transform(normalizeSupportedInboundTools)
 });
-/**
-* Schema for invocation response payloads sent by browser sources.
-*
-* `result` remains permissive and is normalized later to preserve runtime
-* behavior for malformed tool responses.
-*/
 const BrowserToolResultMessageSchema = z.object({
 	type: z.literal("result"),
 	callId: z.string().min(1),
 	result: z.unknown()
 });
-/**
-* Schema for browser heartbeat acknowledgement.
-*/
 const BrowserPongMessageSchema = z.object({ type: z.literal("pong") });
 /**
-* Schema for elicitation request forwarded from a browser tool handler.
-*
-* When a WebMCP tool handler calls `elicitInput()`, the embed script
-* intercepts the call and forwards the parameters to the relay via this
-* message type. The relay then sends `elicitation/create` to the MCP
-* client (e.g. Claude Code) and returns the result via an
-* `elicitation-response` message.
-*/
-const BrowserElicitationRequestSchema = z.object({
-	type: z.literal("elicitation-request"),
-	callId: z.string().min(1),
-	params: z.record(z.string(), z.unknown())
-});
-/**
 * Union schema for all browser-to-relay protocol messages.
 */
 const BrowserToRelayMessageSchema = z.discriminatedUnion("type", [
@@ -451,8 +383,7 @@ const BrowserToRelayMessageSchema = z.discriminatedUnion("type", [
 	BrowserToolsListMessageSchema,
 	BrowserToolsChangedMessageSchema,
 	BrowserToolResultMessageSchema,
-	BrowserPongMessageSchema,
-	BrowserElicitationRequestSchema
+	BrowserPongMessageSchema
 ]);
 /**
 * Shared relay identity used for discovery and attach verification.
@@ -486,34 +417,15 @@ const RelayHelloRejectedMessageSchema = z.object({
 	reason: z.string().min(1),
 	message: z.string().min(1)
 });
-/**
-* Schema for relay invocation messages sent to browser sources.
-*/
 const RelayInvokeMessageSchema = z.object({
 	type: z.literal("invoke"),
 	callId: z.string().min(1),
 	toolName: z.string().min(1),
 	args: RelayInvokeArgsSchema
 });
-/**
-* Schema for relay heartbeat messages sent to browser sources.
-*/
 const RelayPingMessageSchema = z.object({ type: z.literal("ping") });
-/**
-* Schema for relay reload messages sent to browser sources.
-*/
 const RelayReloadMessageSchema = z.object({ type: z.literal("reload") });
 /**
-* Schema for elicitation response sent from relay to browser.
-*
-* Contains the MCP client's response to an `elicitation/create` request.
-*/
-const RelayElicitationResponseSchema = z.object({
-	type: z.literal("elicitation-response"),
-	callId: z.string().min(1),
-	result: z.record(z.string(), z.unknown())
-});
-/**
 * Union schema for all relay-to-browser protocol messages.
 */
 const RelayToBrowserMessageSchema = z.discriminatedUnion("type", [
@@ -522,13 +434,9 @@ const RelayToBrowserMessageSchema = z.discriminatedUnion("type", [
 	RelayHelloRejectedMessageSchema,
 	RelayInvokeMessageSchema,
 	RelayPingMessageSchema,
-	RelayReloadMessageSchema,
-	RelayElicitationResponseSchema
+	RelayReloadMessageSchema
 ]);
 /**
-* Relay-to-relay protocol (client mode <-> server mode).
-*/
-/**
 * Schema for source metadata transmitted in relay-to-relay messages.
 */
 const RelaySourceInfoSchema = z.object({
@@ -542,17 +450,8 @@ const RelaySourceInfoSchema = z.object({
 	lastSeenAt: z.number(),
 	toolCount: z.number()
 });
-/**
-* Schema for relay client identification message.
-*/
 const RelayClientHelloSchema = z.object({ type: z.literal("relay/hello") });
-/**
-* Schema for relay client tool list request.
-*/
 const RelayClientListToolsSchema = z.object({ type: z.literal("relay/list-tools") });
-/**
-* Schema for relay client tool invocation request.
-*/
 const RelayClientInvokeSchema = z.object({
 	type: z.literal("relay/invoke"),
 	callId: z.string().min(1),
@@ -569,27 +468,18 @@ const RelayClientToServerMessageSchema = z.discriminatedUnion("type", [
 ]);
 const RelayToolsPayloadFields = {
 	tools: z.array(NormalizedToolSchema),
-	sources: z.array(RelaySourceInfoSchema).optional().default([]),
-	toolSourceMap: z.record(z.string(), z.array(z.string())).optional().default({})
+	sources: z.array(RelaySourceInfoSchema),
+	toolSourceMap: z.record(z.string(), z.array(z.string()))
 };
-/**
-* Schema for relay server tool list response.
-*/
 const RelayServerToolsSchema = z.object({
 	type: z.literal("relay/tools"),
 	...RelayToolsPayloadFields
 });
-/**
-* Schema for relay server invocation result response.
-*/
 const RelayServerResultSchema = z.object({
 	type: z.literal("relay/result"),
 	callId: z.string().min(1),
 	result: CallToolResultSchema
 });
-/**
-* Schema for relay server push notification when tools change.
-*/
 const RelayServerToolsChangedSchema = z.object({
 	type: z.literal("relay/tools-changed"),
 	...RelayToolsPayloadFields
@@ -651,7 +541,9 @@ var RelayBridgeServer = class extends EventEmitter {
 	instanceId;
 	wss = null;
 	socketByConnectionId = /* @__PURE__ */ new Map();
+	requestOriginByConnectionId = /* @__PURE__ */ new Map();
 	pendingInvocations = /* @__PURE__ */ new Map();
+	browserClientConnectionIds = /* @__PURE__ */ new Set();
 	relayClientConnectionIds = /* @__PURE__ */ new Set();
 	heartbeatIntervalByConnectionId = /* @__PURE__ */ new Map();
 	lastPongByConnectionId = /* @__PURE__ */ new Map();
@@ -687,15 +579,15 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.persistPath = options.persistPath ?? defaultRelayPortPersistPath();
 		this.allowedOrigins = options.allowedOrigins ?? ["*"];
 		this.maxPayloadBytes = options.maxPayloadBytes ?? 1e7;
-		this.invokeTimeoutMs = options.invokeTimeoutMs ?? 25e3;
+		this.invokeTimeoutMs = options.invokeTimeoutMs ?? 65e3;
 		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 (!Number.isInteger(this.preferredPort) || this.preferredPort < 0 || this.preferredPort > 65535) throw new Error(`Invalid port ${this.preferredPort}. Port must be 0 (auto-assign) or between 1 and 65535.`);
+		if (!Number.isInteger(this.portRangeEnd) || this.portRangeEnd < 1 || this.portRangeEnd > 65535 || this.portRangeEnd < this.preferredPort && this.preferredPort !== 0) throw new Error(`Invalid port range ${this.preferredPort}-${this.portRangeEnd}. rangeEnd must be an integer between the preferred port and 65535.`);
 		if (!Number.isInteger(this.maxPayloadBytes) || this.maxPayloadBytes <= 0) throw new Error(`Invalid maxPayloadBytes ${this.maxPayloadBytes}. Must be a positive integer.`);
-		if (this.invokeTimeoutMs <= 0) throw new Error(`Invalid invokeTimeoutMs ${this.invokeTimeoutMs}. Must be greater than 0.`);
+		if (!Number.isInteger(this.invokeTimeoutMs) || this.invokeTimeoutMs <= 0) throw new Error(`Invalid invokeTimeoutMs ${this.invokeTimeoutMs}. Must be a positive integer.`);
 	}
 	/**
 	* Current operating mode.
@@ -756,12 +648,12 @@ var RelayBridgeServer = class extends EventEmitter {
 		});
 		for (const candidate of candidates) try {
 			await this.startAsServer(candidate.port);
-			await persistPort(this.port, this.persistPath, this.host);
+			await this.persistSelectedPort();
 			return;
 		} catch (err) {
 			if (!this.isAddressInUseError(err)) throw err;
 			if (await this.tryAttachToExistingRelay(candidate.port)) {
-				await persistPort(this.port, this.persistPath, this.host);
+				await this.persistSelectedPort();
 				return;
 			}
 			if (candidate.wasFixed) throw new Error(`Port ${candidate.port} is already in use by a non-WebMCP service and cannot be shared.`);
@@ -772,12 +664,20 @@ var RelayBridgeServer = class extends EventEmitter {
 	isAddressInUseError(error) {
 		return error instanceof Error && ("code" in error ? error.code === "EADDRINUSE" : error.message.includes("EADDRINUSE"));
 	}
+	async persistSelectedPort() {
+		try {
+			await persistPort(this.port, this.persistPath, this.host);
+		} catch (error) {
+			process.stderr.write(`[webmcp-local-relay] warn: could not cache relay port: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+	}
 	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 {
+		} catch (error) {
+			process.stderr.write(`[webmcp-local-relay] info: port ${port} did not complete a relay handshake: ${error instanceof Error ? error.message : String(error)}\n`);
 			return false;
 		}
 	}
@@ -819,6 +719,8 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.heartbeatIntervalByConnectionId.clear();
 		this.lastPongByConnectionId.clear();
 		this.socketByConnectionId.clear();
+		this.requestOriginByConnectionId.clear();
+		this.browserClientConnectionIds.clear();
 		this.relayClientConnectionIds.clear();
 		for (const pending of this.pendingInvocations.values()) {
 			clearTimeout(pending.timeoutId);
@@ -880,16 +782,15 @@ var RelayBridgeServer = class extends EventEmitter {
 			server.once("listening", onListening);
 			server.once("error", onError);
 		});
-		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");
+		wss.on("connection", (socket, request) => {
+			const requestOrigin = request.headers.origin;
+			if (requestOrigin && socket.protocol === RELAY_INTERNAL_PROTOCOL) {
+				socket.close(1008, "Browser connections cannot use the relay protocol");
 				return;
 			}
+			const connectionId = randomUUID();
+			this.socketByConnectionId.set(connectionId, socket);
+			if (requestOrigin) this.requestOriginByConnectionId.set(connectionId, requestOrigin);
 			socket.on("message", (raw) => {
 				this.onSocketMessage(connectionId, raw);
 			});
@@ -898,14 +799,20 @@ var RelayBridgeServer = class extends EventEmitter {
 			});
 			socket.on("error", (err) => {
 				process.stderr.write(`[webmcp-local-relay] warn: socket error for connection ${connectionId}: ${err.message}\n`);
-				const code = err.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? 1009 : void 0;
+				const code = "code" in err && err.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? 1009 : void 0;
 				this.onSocketClose(connectionId, code);
 			});
+			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;
+			}
 			this.startHeartbeat(connectionId);
 		});
 		wss.on("error", (err) => {
 			process.stderr.write(`[webmcp-local-relay] error: WebSocket server error: ${err.message}\n`);
-			this.emit("error", err);
 		});
 		this.wss = wss;
 		this._mode = "server";
@@ -926,11 +833,18 @@ var RelayBridgeServer = class extends EventEmitter {
 			workspace: this.workspace
 		};
 	}
-	invokeToolLocally(toolName, args, options) {
-		const resolveOptions = { toolName };
-		if (options.sourceId !== void 0) resolveOptions.sourceId = options.sourceId;
-		if (options.requestTabId !== void 0) resolveOptions.requestTabId = options.requestTabId;
-		const resolved = this.registry.resolveInvocation(resolveOptions);
+	/**
+	* `async` is load-bearing: {@link onRelayClientMessage} consumes this through
+	* `.then(onResult, onError)`, so a synchronous throw would escape the socket
+	* message handler as an uncaught exception and leave the relay client waiting
+	* for a `relay/result` that never arrives.
+	*/
+	async invokeToolLocally(toolName, args, options) {
+		const resolved = this.registry.resolveInvocation({
+			toolName,
+			...options.sourceId === void 0 ? {} : { sourceId: options.sourceId },
+			...options.requestTabId === void 0 ? {} : { requestTabId: options.requestTabId }
+		});
 		if (!resolved) throw new Error(`No active browser source provides tool "${toolName}"`);
 		const socket = this.socketByConnectionId.get(resolved.connectionId);
 		if (!socket || socket.readyState !== WebSocket.OPEN) throw new Error(`Tool source ${resolved.connectionId} disconnected before invocation of "${toolName}"`);
@@ -941,7 +855,6 @@ var RelayBridgeServer = class extends EventEmitter {
 				reject(/* @__PURE__ */ new Error(`Invocation for tool "${toolName}" timed out after ${this.invokeTimeoutMs}ms`));
 			}, this.invokeTimeoutMs);
 			this.pendingInvocations.set(callId, {
-				callId,
 				connectionId: resolved.connectionId,
 				timeoutId,
 				resolve,
@@ -962,12 +875,7 @@ var RelayBridgeServer = class extends EventEmitter {
 			}
 		});
 	}
-	/**
-	* Handles a raw WebSocket message from a connected source.
-	*
-	* Routes relay-protocol messages (`relay/*`) to the relay client handler
-	* and browser-protocol messages to the existing browser handler.
-	*/
+	/** Handles a raw message according to the negotiated WebSocket protocol. */
 	onSocketMessage(connectionId, raw) {
 		const text = this.rawDataToUtf8(raw);
 		let parsedJson;
@@ -978,26 +886,40 @@ var RelayBridgeServer = class extends EventEmitter {
 			process.stderr.write(`[webmcp-local-relay] warn: invalid JSON from connection ${connectionId} (${err instanceof Error ? err.message : "parse error"}): ${preview}\n`);
 			return;
 		}
-		const typeField = typeof parsedJson === "object" && parsedJson !== null ? parsedJson.type : void 0;
-		if (typeof typeField === "string" && typeField.startsWith("relay/")) {
+		const typeField = typeof parsedJson === "object" && parsedJson !== null && "type" in parsedJson ? parsedJson.type : void 0;
+		const socket = this.socketByConnectionId.get(connectionId);
+		if (!socket) return;
+		if (socket.protocol === RELAY_INTERNAL_PROTOCOL) {
 			const relayMsg = RelayClientToServerMessageSchema.safeParse(parsedJson);
 			if (relayMsg.success) this.onRelayClientMessage(connectionId, relayMsg.data);
 			else process.stderr.write(`[webmcp-local-relay] warn: invalid relay message from ${connectionId}: ${relayMsg.error.message}\n`);
 			return;
 		}
-		this.registry.touchConnection(connectionId);
+		if (typeof typeField === "string" && typeField.startsWith("relay/")) {
+			process.stderr.write(`[webmcp-local-relay] warn: connection ${connectionId} used the relay protocol without negotiating it\n`);
+			socket.close(1008, "Relay protocol was not negotiated");
+			return;
+		}
 		const parsedMessage = BrowserToRelayMessageSchema.safeParse(parsedJson);
 		if (!parsedMessage.success) {
 			process.stderr.write(`[webmcp-local-relay] warn: invalid message from connection ${connectionId} (type=${typeField}): ${parsedMessage.error.message}\n`);
 			return;
 		}
-		const message = parsedMessage.data;
+		this.registry.touchConnection(connectionId);
+		this.onBrowserClientMessage(connectionId, parsedMessage.data);
+	}
+	onBrowserClientMessage(connectionId, message) {
+		if (message.type !== "hello" && !this.browserClientConnectionIds.has(connectionId)) {
+			process.stderr.write(`[webmcp-local-relay] warn: connection ${connectionId} sent ${message.type} before hello, ignoring\n`);
+			return;
+		}
 		switch (message.type) {
 			case "hello":
 				try {
 					const socket = this.socketByConnectionId.get(connectionId);
-					if (!this.isHostOriginAllowed(message.origin)) {
-						process.stderr.write(`[webmcp-local-relay] warn: rejecting source ${connectionId} with disallowed host origin: ${message.origin ?? "missing"}\n`);
+					const origin = this.requestOriginByConnectionId.get(connectionId) ?? message.origin;
+					if (!this.isHostOriginAllowed(origin)) {
+						process.stderr.write(`[webmcp-local-relay] warn: rejecting source ${connectionId} with disallowed host origin: ${origin ?? "missing"}\n`);
 						if (socket) this.sendHelloRejected(socket, {
 							type: "hello/rejected",
 							reason: "host-origin-not-allowed",
@@ -1005,7 +927,11 @@ var RelayBridgeServer = class extends EventEmitter {
 						}, 1008, "Host origin not allowed");
 						break;
 					}
-					this.registry.upsertSource(connectionId, message);
+					this.registry.upsertSource(connectionId, {
+						...message,
+						origin
+					});
+					this.browserClientConnectionIds.add(connectionId);
 					if (socket) this.sendHelloAccepted(socket, { type: "hello/accepted" });
 					this.emit("stateChanged");
 				} catch (err) {
@@ -1018,11 +944,8 @@ var RelayBridgeServer = class extends EventEmitter {
 					this.registry.registerTools(connectionId, message.tools);
 					this.emit("stateChanged");
 				} catch (err) {
-					if (err instanceof HelloRequiredError) process.stderr.write(`[webmcp-local-relay] warn: connection ${connectionId} sent tools before hello, ignoring\n`);
-					else {
-						process.stderr.write(`[webmcp-local-relay] error: failed to register tools for connection ${connectionId}: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
-						this.socketByConnectionId.get(connectionId)?.close(1011, "Failed to register tools");
-					}
+					process.stderr.write(`[webmcp-local-relay] error: failed to register tools for connection ${connectionId}: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+					this.socketByConnectionId.get(connectionId)?.close(1008, "Invalid tool list");
 				}
 				break;
 			case "result": {
@@ -1031,6 +954,10 @@ var RelayBridgeServer = class extends EventEmitter {
 					process.stderr.write(`[webmcp-local-relay] warn: received result for unknown callId ${message.callId}\n`);
 					break;
 				}
+				if (pending.connectionId !== connectionId) {
+					process.stderr.write(`[webmcp-local-relay] warn: connection ${connectionId} returned result for another source's callId ${message.callId}\n`);
+					break;
+				}
 				clearTimeout(pending.timeoutId);
 				this.pendingInvocations.delete(message.callId);
 				pending.resolve(this.normalizeCallToolResult(message.result));
@@ -1039,39 +966,16 @@ var RelayBridgeServer = class extends EventEmitter {
 			case "pong":
 				this.lastPongByConnectionId.set(connectionId, Date.now());
 				break;
-			case "elicitation-request":
-				this.emit("elicitationRequest", {
-					callId: message.callId,
-					connectionId,
-					params: message.params
-				});
-				break;
-		}
-	}
-	/**
-	* Sends an elicitation response back to the browser source that requested it.
-	*/
-	sendElicitationResponse(connectionId, callId, result) {
-		const socket = this.socketByConnectionId.get(connectionId);
-		if (!socket || socket.readyState !== WebSocket.OPEN) {
-			process.stderr.write(`[webmcp-local-relay] warn: cannot send elicitation response: source ${connectionId} disconnected\n`);
-			return;
-		}
-		const message = {
-			type: "elicitation-response",
-			callId,
-			result
-		};
-		try {
-			socket.send(JSON.stringify(message));
-		} catch (err) {
-			process.stderr.write(`[webmcp-local-relay] warn: failed to send elicitation response: ${err instanceof Error ? err.message : String(err)}\n`);
 		}
 	}
 	/**
 	* Handles relay-protocol messages from relay client connections.
 	*/
 	onRelayClientMessage(connectionId, message) {
+		if (message.type !== "relay/hello" && !this.relayClientConnectionIds.has(connectionId)) {
+			process.stderr.write(`[webmcp-local-relay] warn: connection ${connectionId} sent ${message.type} before relay/hello, ignoring\n`);
+			return;
+		}
 		switch (message.type) {
 			case "relay/hello":
 				this.relayClientConnectionIds.add(connectionId);
@@ -1088,45 +992,33 @@ var RelayBridgeServer = class extends EventEmitter {
 			}
 			case "relay/invoke": {
 				const { callId, toolName, args } = message;
-				(async () => {
-					try {
-						const response = {
-							type: "relay/result",
-							callId,
-							result: await this.invokeToolLocally(toolName, args ?? {}, {})
-						};
-						const socket = this.socketByConnectionId.get(connectionId);
-						if (socket?.readyState === WebSocket.OPEN) try {
-							socket.send(JSON.stringify(response));
-						} catch (sendErr) {
-							process.stderr.write(`[webmcp-local-relay] warn: failed to send relay result to ${connectionId}: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}\n`);
-						}
-						else process.stderr.write(`[webmcp-local-relay] warn: relay client ${connectionId} disconnected before result for callId ${callId} could be delivered\n`);
-					} catch (err) {
-						const response = {
-							type: "relay/result",
-							callId,
-							result: {
-								content: [{
-									type: "text",
-									text: `Relay invocation failed: ${err instanceof Error ? err.message : String(err)}`
-								}],
-								isError: true
-							}
-						};
-						const socket = this.socketByConnectionId.get(connectionId);
-						if (socket?.readyState === WebSocket.OPEN) try {
-							socket.send(JSON.stringify(response));
-						} catch (sendErr) {
-							process.stderr.write(`[webmcp-local-relay] warn: failed to send relay error result to ${connectionId}: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}\n`);
-						}
-						else process.stderr.write(`[webmcp-local-relay] warn: relay client ${connectionId} disconnected before error result for callId ${callId} could be delivered\n`);
-					}
-				})();
+				this.invokeToolLocally(toolName, args ?? {}, {}).then((result) => this.sendRelayResult(connectionId, callId, result), (error) => this.sendRelayResult(connectionId, callId, {
+					content: [{
+						type: "text",
+						text: `Relay invocation failed: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				}));
 				break;
 			}
 		}
 	}
+	sendRelayResult(connectionId, callId, result) {
+		const socket = this.socketByConnectionId.get(connectionId);
+		if (socket?.readyState !== WebSocket.OPEN) {
+			process.stderr.write(`[webmcp-local-relay] warn: relay client ${connectionId} disconnected before result for callId ${callId} could be delivered\n`);
+			return;
+		}
+		try {
+			socket.send(JSON.stringify({
+				type: "relay/result",
+				callId,
+				result
+			}));
+		} catch (error) {
+			process.stderr.write(`[webmcp-local-relay] warn: failed to send relay result to ${connectionId}: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+	}
 	/**
 	* Pushes current tool state to all connected relay clients.
 	*/
@@ -1152,6 +1044,8 @@ var RelayBridgeServer = class extends EventEmitter {
 	onSocketClose(connectionId, code) {
 		if (!this.socketByConnectionId.has(connectionId)) return;
 		this.stopHeartbeat(connectionId);
+		this.requestOriginByConnectionId.delete(connectionId);
+		this.browserClientConnectionIds.delete(connectionId);
 		this.relayClientConnectionIds.delete(connectionId);
 		this.registry.removeConnection(connectionId);
 		this.socketByConnectionId.delete(connectionId);
@@ -1216,10 +1110,9 @@ var RelayBridgeServer = class extends EventEmitter {
 		}
 	}
 	async connectToRelayServer(port) {
-		this.stopping = false;
 		return new Promise((resolve, reject) => {
 			const wsUrl = `ws://${this.host}:${port}`;
-			const ws = new WebSocket(wsUrl, [RELAY_INTERNAL_PROTOCOL, RELAY_BROWSER_PROTOCOL]);
+			const ws = new WebSocket(wsUrl, RELAY_INTERNAL_PROTOCOL);
 			const bufferedMessages = [];
 			const cleanup = () => {
 				clearTimeout(timeoutId);
@@ -1229,8 +1122,9 @@ var RelayBridgeServer = class extends EventEmitter {
 				ws.off("open", onOpen);
 			};
 			const rejectWith = (error) => {
-				ws.once("error", () => {});
 				cleanup();
+				ws.once("error", () => {});
+				ws.terminate();
 				reject(error);
 			};
 			const finish = () => {
@@ -1319,7 +1213,7 @@ var RelayBridgeServer = class extends EventEmitter {
 		}
 		const message = RelayServerToClientMessageSchema.safeParse(parsed);
 		if (!message.success) {
-			const typeField = typeof parsed === "object" && parsed !== null ? parsed.type : "unknown";
+			const typeField = typeof parsed === "object" && parsed !== null && "type" in parsed ? parsed.type : "unknown";
 			process.stderr.write(`[webmcp-local-relay] warn: invalid relay server message (type=${typeField}): ${message.error.message}\n`);
 			return null;
 		}
@@ -1360,10 +1254,7 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.clientReconnectTimer = setTimeout(() => {
 			this.clientReconnectTimer = null;
 			if (this.stopping) return;
-			this.reconnectWithModePromotion().catch((err) => {
-				process.stderr.write(`[webmcp-local-relay] error: unexpected failure during reconnection: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
-				if (!this.stopping) this.scheduleReconnect();
-			});
+			this.reconnectWithModePromotion();
 		}, delay);
 	}
 	/**
@@ -1384,7 +1275,7 @@ var RelayBridgeServer = class extends EventEmitter {
 			if (!this.stopping) this.scheduleReconnect();
 		}
 	}
-	invokeToolViaRelay(toolName, args) {
+	async invokeToolViaRelay(toolName, args) {
 		if (!this.clientSocket || this.clientSocket.readyState !== WebSocket.OPEN) throw new Error("Not connected to relay server");
 		const callId = randomUUID();
 		const socket = this.clientSocket;
@@ -1394,7 +1285,6 @@ var RelayBridgeServer = class extends EventEmitter {
 				reject(/* @__PURE__ */ new Error(`Proxied invocation for tool "${toolName}" timed out after ${this.invokeTimeoutMs}ms`));
 			}, this.invokeTimeoutMs);
 			this.clientPendingInvocations.set(callId, {
-				callId,
 				connectionId: "relay-server",
 				timeoutId,
 				resolve,
@@ -1425,17 +1315,11 @@ var RelayBridgeServer = class extends EventEmitter {
 		for (const tool of tools) toolSourceMap[tool.name] = tool.sources.map((s) => s.sourceId);
 		return {
 			type,
-			tools: this.toWireTools(tools),
+			tools: tools.map(({ originalName: _originalName, sources: _sources, ...tool }) => tool),
 			sources,
 			toolSourceMap
 		};
 	}
-	/**
-	* Maps aggregated tools to the wire format used by the relay protocol.
-	*/
-	toWireTools(tools) {
-		return tools.map(({ originalName: _originalName, sources: _sources, ...tool }) => tool);
-	}
 	isHostOriginAllowed(origin) {
 		if (this.allowedOrigins.includes("*")) return true;
 		if (!origin) return false;
@@ -1482,86 +1366,68 @@ var RelayBridgeServer = class extends EventEmitter {
 	* Converts WebSocket raw data variants to a UTF-8 string payload.
 	*/
 	rawDataToUtf8(raw) {
-		if (typeof raw === "string") return raw;
-		if (Buffer.isBuffer(raw)) return raw.toString("utf8");
-		if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
 		if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
-		return String(raw);
+		if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+		return Buffer.from(raw).toString("utf8");
 	}
 };
 
 //#endregion
 //#region src/cli-utils.ts
+function parsePositiveInteger(name, value) {
+	if (value === void 0) return void 0;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`Invalid ${name} "${value}". Must be a positive integer.`);
+	return parsed;
+}
 /**
 * Parses supported CLI flags for relay startup.
 */
 function parseCliOptions(argv) {
-	const options = {
-		host: "127.0.0.1",
-		port: 9333,
-		portExplicitlySet: false,
-		allowedOrigins: ["*"]
-	};
-	const readFlagValue = (flag, index) => {
-		const next = argv[index + 1];
-		if (!next || next.startsWith("-")) throw new Error(`Missing value for ${flag}`);
-		return next;
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			host: {
+				type: "string",
+				short: "H"
+			},
+			"allowed-origin": { type: "string" },
+			"invoke-timeout": { type: "string" },
+			label: { type: "string" },
+			"max-payload": { type: "string" },
+			port: {
+				type: "string",
+				short: "p"
+			},
+			"relay-id": { type: "string" },
+			"widget-origin": { type: "string" },
+			workspace: { type: "string" },
+			"ws-origin": { type: "string" }
+		},
+		strict: true
+	});
+	const port = values.port === void 0 ? DEFAULT_RELAY_PORT : Number(values.port);
+	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error(`Invalid port "${values.port}". Port must be an integer between 1 and 65535.`);
+	const invokeTimeoutMs = parsePositiveInteger("invoke-timeout", values["invoke-timeout"]);
+	const maxPayloadBytes = parsePositiveInteger("max-payload", values["max-payload"]);
+	const allowedOrigins = (values["widget-origin"] ?? values["allowed-origin"] ?? values["ws-origin"])?.split(",").map((origin) => origin.trim()).filter(Boolean) ?? ["*"];
+	if (allowedOrigins.length === 0) throw new Error("--widget-origin must include at least one origin.");
+	return {
+		allowedOrigins,
+		help: values.help ?? false,
+		host: values.host ?? "127.0.0.1",
+		port,
+		portExplicitlySet: values.port !== void 0,
+		...values.label === void 0 ? {} : { label: values.label },
+		...invokeTimeoutMs === void 0 ? {} : { invokeTimeoutMs },
+		...maxPayloadBytes === void 0 ? {} : { maxPayloadBytes },
+		...values["relay-id"] === void 0 ? {} : { relayId: values["relay-id"] },
+		...values.workspace === void 0 ? {} : { workspace: values.workspace }
 	};
-	for (let i = 0; i < argv.length; i++) {
-		const token = argv[i];
-		if (!token) continue;
-		if (token === "--host" || token === "-H") {
-			options.host = readFlagValue(token, i);
-			i += 1;
-			continue;
-		}
-		if (token === "--port" || token === "-p") {
-			const raw = readFlagValue(token, i);
-			i += 1;
-			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") {
-			const raw = readFlagValue(token, i);
-			i += 1;
-			const split = raw.split(",").map((part) => part.trim()).filter(Boolean);
-			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 === "--max-payload") {
-			const raw = readFlagValue(token, i);
-			i += 1;
-			const value = Number(raw);
-			if (!Number.isInteger(value) || value <= 0) throw new Error(`Invalid max-payload "${raw}". Must be a positive integer (bytes).`);
-			options.maxPayloadBytes = value;
-			continue;
-		}
-		if (token === "--help" || token === "-h") {
-			printHelp();
-			process.exit(0);
-		}
-		if (token.startsWith("-")) process.stderr.write(`[webmcp-local-relay] warn: unrecognized argument "${token}"\n`);
-		else process.stderr.write(`[webmcp-local-relay] warn: unrecognized argument "${token}" (positional arguments are not supported)\n`);
-	}
-	return options;
 }
 /**
 * Prints CLI usage to stderr.
@@ -1577,48 +1443,18 @@ function printHelp() {
 		"  --host, -H               Bind host for local websocket relay (default: 127.0.0.1)",
 		"  --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",
+		"  --allowed-origin         Deprecated alias for --widget-origin",
+		"  --ws-origin              Deprecated 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",
+		"  --invoke-timeout         Browser tool invocation timeout in milliseconds (default: 65000)",
 		"  --max-payload            Maximum WebSocket payload size in bytes (default: 10000000)",
 		"  --help, -h               Show help",
 		""
 	].join("\n"));
 }
 
-//#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
 /**
@@ -1630,12 +1466,7 @@ 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;
+	dynamicTools = /* @__PURE__ */ new Map();
 	syncDebounceTimer = null;
 	connected = false;
 	/**
@@ -1650,31 +1481,14 @@ var LocalRelayMcpServer = class {
 		this.bridge.on("stateChanged", () => {
 			this.debouncedSyncDynamicTools();
 		});
-		this.bridge.on("elicitationRequest", (request) => {
-			(async () => {
-				try {
-					const result = await this.mcpServer.server.elicitInput(request.params);
-					this.bridge.sendElicitationResponse(request.connectionId, request.callId, result);
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					process.stderr.write(`[webmcp-local-relay] warn: elicitation forwarding failed: ${message}\n`);
-					this.bridge.sendElicitationResponse(request.connectionId, request.callId, {
-						action: "decline",
-						content: null,
-						error: message
-					});
-				}
-			})();
-		});
 		this.registerStaticTools();
-		this.overrideListToolsHandler();
 	}
 	/**
 	* Starts the browser bridge and synchronizes dynamic MCP tools.
 	*/
 	async start() {
 		await this.bridge.start();
-		await this.syncDynamicTools();
+		this.syncDynamicTools();
 	}
 	/**
 	* Connects the MCP server to a transport.
@@ -1718,289 +1532,147 @@ var LocalRelayMcpServer = class {
 	* Returns dynamic tool names currently registered in MCP.
 	*/
 	listDynamicToolNames() {
-		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 } : {}
-		});
+		return Array.from(this.dynamicTools.keys()).sort();
 	}
 	/**
 	* Registers built-in management tools exposed by the relay.
 	*/
 	registerStaticTools() {
-		this.registerStaticTool({
-			name: "webmcp_list_sources",
+		this.mcpServer.registerTool("webmcp_list_sources", {
 			description: "List connected browser tool sources and their metadata.",
-			inputShape: EMPTY_STATIC_TOOL_INPUT_SHAPE,
+			inputSchema: z.object({}),
 			annotations: {
 				readOnlyHint: true,
 				idempotentHint: true
-			},
-			handler: async () => {
-				if (this.bridge.mode === "client") {
-					const sources = this.bridge.listSourcesFromRelay();
-					const info = {
-						mode: "client",
-						count: sources.length,
-						sources
-					};
-					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({
-							count: sources.length,
-							sources
-						}, null, 2)
-					}],
-					structuredContent: {
-						count: sources.length,
-						sources
-					}
-				};
 			}
+		}, async () => {
+			const clientMode = this.bridge.mode === "client";
+			const sources = clientMode ? this.bridge.listSourcesFromRelay() : this.bridge.registry.listSources();
+			const info = {
+				...clientMode ? { mode: "client" } : {},
+				count: sources.length,
+				sources
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(info, null, 2)
+				}],
+				structuredContent: info
+			};
 		});
-		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.",
-			inputShape: EMPTY_STATIC_TOOL_INPUT_SHAPE,
+		this.mcpServer.registerTool("webmcp_list_tools", {
+			description: "List WebMCP tools available from connected browser sources. Returns tool definitions including name, description, input schema, and source info.",
+			inputSchema: z.object({}),
 			annotations: {
 				readOnlyHint: true,
 				idempotentHint: true
-			},
-			handler: async () => {
-				const tools = this.listAggregatedTools();
+			}
+		}, async () => {
+			const tools = this.listAggregatedTools();
+			const info = {
+				count: tools.length,
+				tools
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(info, null, 2)
+				}],
+				structuredContent: info
+			};
+		});
+		this.mcpServer.registerTool("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: z.object({
+				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: JSON.stringify({
-							count: tools.length,
-							tools
-						}, null, 2)
+						text: `Invalid URL: ${url}`
 					}],
-					structuredContent: {
-						count: tools.length,
-						tools
-					}
+					isError: true
 				};
 			}
-		});
-		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, {
+			if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
+				content: [{
+					type: "text",
+					text: `Only http: and https: URLs are allowed. Got: ${parsed.protocol}`
+				}],
+				isError: true
+			};
+			const existing = this.bridge.mode === "server" ? this.bridge.registry.listSources().find((source) => source.url && URL.parse(source.url)?.origin === parsed.origin) : void 0;
+			if (refresh) {
+				if (this.bridge.mode === "client") return {
+					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: [{
-							type: "text",
-							text: errorLines.join("\n")
-						}],
-						isError: true
-					};
-				}
-			}
-		});
-		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.",
-			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 {
+						text: "Refresh is not supported in client mode. Only the server relay can reload sources."
+					}],
+					isError: true
+				};
+				if (!existing) return {
 					content: [{
 						type: "text",
-						text: `Only http: and https: URLs are allowed. Got: ${parsed.protocol}`
+						text: `No connected source matches origin ${parsed.origin}. The page may not be open or connected.`
 					}],
 					isError: true
 				};
-				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 {
-						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
-						};
-					}
-				}
 				try {
-					await this.openInBrowser(url);
+					this.bridge.reloadSource(existing.sourceId);
+					return { content: [{
+						type: "text",
+						text: `Reload sent to source ${existing.sourceId} (${existing.url ?? existing.origin}).`
+					}] };
 				} catch (err) {
 					return {
 						content: [{
 							type: "text",
-							text: `Failed to open browser: ${err instanceof Error ? err.message : String(err)}`
+							text: `Failed to reload source: ${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: [{
+			}
+			try {
+				await this.openInBrowser(url);
+			} catch (err) {
+				return {
+					content: [{
 						type: "text",
-						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.`
-				}] };
+						text: `Failed to open browser: ${err instanceof Error ? err.message : String(err)}`
+					}],
+					isError: true
+				};
 			}
+			if (existing) return { content: [{
+				type: "text",
+				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.`
+			}] };
 		});
 	}
 	/**
-	* Builds a concise plain-text list of available tools.
-	*/
-	buildToolSummary(tools) {
-		if (tools.length === 0) return null;
-		return tools.map((t) => {
-			const desc = t.description ? ` - ${t.description.split("\n")[0]}` : "";
-			return `  ${t.name}${desc}`;
-		}).join("\n");
-	}
-	/**
 	* Opens a URL in the user's default browser using the platform open command.
 	*
-	* Uses the re-serialized `URL.href` to prevent injection of shell metacharacters.
-	* On Windows, PowerShell `Start-Process` is used instead of `cmd /c start`
-	* because cmd.exe interprets `&`, `|`, and other metacharacters in URLs.
+	* Passes the re-serialized `URL.href` directly to the platform launcher.
+	* No shell or command-language string is involved.
 	*/
 	openInBrowser(url) {
 		const safeUrl = new URL(url).href;
+		const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open";
 		return new Promise((resolve, reject) => {
-			const platform = process.platform;
-			let command;
-			let args;
-			if (platform === "darwin") {
-				command = "open";
-				args = [safeUrl];
-			} else if (platform === "win32") {
-				command = "powershell.exe";
-				args = [
-					"-NoProfile",
-					"-Command",
-					`Start-Process "${safeUrl}"`
-				];
-			} else {
-				command = "xdg-open";
-				args = [safeUrl];
-			}
-			execFile(command, args, (err) => {
+			execFile(command, [safeUrl], (err) => {
 				if (err) reject(err);
 				else resolve();
 			});
@@ -2018,36 +1690,15 @@ var LocalRelayMcpServer = class {
 		if (this.syncDebounceTimer) return;
 		this.syncDebounceTimer = setTimeout(() => {
 			this.syncDebounceTimer = null;
-			this.syncDynamicTools().catch((err) => {
-				this.logSyncError(err);
-			});
+			try {
+				this.syncDynamicTools();
+			} catch (err) {
+				const details = err instanceof Error ? err.stack ?? err.message : String(err);
+				process.stderr.write(`[webmcp-local-relay] error: failed to sync dynamic tools: ${details}\n`);
+			}
 		}, 16);
 	}
 	/**
-	* Coalesces concurrent sync requests into a single serialized sync loop.
-	*/
-	async syncDynamicTools() {
-		if (this.syncing) {
-			this.syncRequested = true;
-			return;
-		}
-		this.syncing = true;
-		try {
-			do {
-				this.syncRequested = false;
-				const tools = this.listAggregatedTools();
-				this.applyDynamicTools(tools);
-			} while (this.syncRequested);
-		} finally {
-			const retryRequested = this.syncRequested;
-			this.syncRequested = false;
-			this.syncing = false;
-			if (retryRequested) this.syncDynamicTools().catch((err) => {
-				this.logSyncError(err);
-			});
-		}
-	}
-	/**
 	* Returns the current aggregated tool list, dispatching based on bridge mode.
 	*/
 	listAggregatedTools() {
@@ -2077,52 +1728,51 @@ var LocalRelayMcpServer = class {
 		}).sort((left, right) => left.name.localeCompare(right.name));
 	}
 	/**
-	* Applies registry tool state to MCP dynamic registrations.
+	* Applies current aggregated tool state to MCP dynamic registrations.
 	*/
-	applyDynamicTools(tools) {
+	syncDynamicTools() {
+		const tools = this.listAggregatedTools();
 		const nextNames = new Set(tools.map((tool) => tool.name));
-		let changed = false;
-		for (const [name, handle] of this.dynamicToolHandles.entries()) {
+		for (const [name, registration] of this.dynamicTools) {
 			if (nextNames.has(name)) continue;
-			handle.remove();
-			this.dynamicToolHandles.delete(name);
-			this.dynamicToolData.delete(name);
-			this.dynamicToolSignature.delete(name);
-			changed = true;
+			registration.handle.remove();
+			this.dynamicTools.delete(name);
 		}
 		for (const tool of tools) {
 			const signature = this.toolSignature(tool);
-			if (this.dynamicToolSignature.get(tool.name) === signature && this.dynamicToolHandles.has(tool.name)) continue;
-			const existing = this.dynamicToolHandles.get(tool.name);
-			if (existing) {
-				existing.remove();
-				this.dynamicToolHandles.delete(tool.name);
+			const current = this.dynamicTools.get(tool.name);
+			if (current?.signature === signature) continue;
+			if (current) {
+				current.handle.remove();
+				this.dynamicTools.delete(tool.name);
+			}
+			try {
+				const handle = this.registerDynamicTool(tool);
+				this.dynamicTools.set(tool.name, {
+					handle,
+					signature
+				});
+			} catch (err) {
+				const details = err instanceof Error ? err.stack ?? err.message : String(err);
+				process.stderr.write(`[webmcp-local-relay] warn: skipped dynamic tool "${tool.name}" because its schema could not be compiled: ${details}\n`);
 			}
-			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;
-		}
-		if (changed && this.connected) try {
-			this.mcpServer.sendToolListChanged();
-		} catch (err) {
-			process.stderr.write(`[webmcp-local-relay] warn: failed to send tool list changed notification: ${err instanceof Error ? err.message : String(err)}\n`);
 		}
 	}
 	/**
 	* Registers a single dynamic tool and returns a removal handle.
 	*/
 	registerDynamicTool(tool) {
-		const inputSchema = z.object({}).passthrough();
-		const config = {
+		const inputSchema = fromJsonSchema(tool.inputSchema);
+		const outputSchema = tool.outputSchema ? fromJsonSchema(tool.outputSchema) : void 0;
+		return this.mcpServer.registerTool(tool.name, {
+			...tool.title !== void 0 ? { title: tool.title } : {},
 			description: this.dynamicToolDescription(tool),
-			inputSchema
-		};
-		const handle = this.mcpServer.registerTool(tool.name, tool.annotations ? {
-			...config,
-			annotations: tool.annotations
-		} : config, async (args) => {
+			inputSchema,
+			...outputSchema ? { outputSchema } : {},
+			...tool.annotations ? { annotations: tool.annotations } : {},
+			...tool.icons ? { icons: tool.icons } : {},
+			...tool._meta ? { _meta: tool._meta } : {}
+		}, async (args) => {
 			try {
 				return await this.bridge.invokeTool(tool.name, args);
 			} catch (err) {
@@ -2138,9 +1788,6 @@ var LocalRelayMcpServer = class {
 				};
 			}
 		});
-		return { remove: () => {
-			handle.remove();
-		} };
 	}
 	/**
 	* Builds a display description for relayed tools including source context.
@@ -2159,28 +1806,22 @@ var LocalRelayMcpServer = class {
 	*/
 	toolSignature(tool) {
 		return JSON.stringify({
-			name: tool.name,
 			originalName: tool.originalName,
 			title: tool.title,
 			description: tool.description,
 			inputSchema: tool.inputSchema,
 			outputSchema: tool.outputSchema,
 			annotations: tool.annotations,
-			execution: tool.execution,
 			_meta: tool._meta,
 			icons: tool.icons,
-			sources: tool.sources.map((source) => ({ tabId: source.tabId }))
+			source: tool.sources[0] ? {
+				tabId: tool.sources[0].tabId,
+				title: tool.sources[0].title
+			} : void 0
 		});
 	}
-	/**
-	* Logs tool sync errors with full detail.
-	*/
-	logSyncError(err) {
-		const details = err instanceof Error ? err.stack ?? err.message : String(err);
-		process.stderr.write(`[webmcp-local-relay] error: failed to sync dynamic tools: ${details}\n`);
-	}
 };
 
 //#endregion
 export { NormalizedToolSchema as C, normalizeInboundTool as D, ToolSchema as E, InboundToolSchema as S, ToolAnnotationsSchema as T, extractSanitizedDomain as _, BrowserToRelayMessageSchema as a, CallToolResultSchema as b, RelayHelloAcceptedMessageSchema as c, RelaySourceInfoSchema as d, RelayToBrowserMessageSchema as f, buildPublicToolName as g, RelayRegistry as h, RelayBridgeServer as i, RelayHelloRejectedMessageSchema as l, HelloRequiredError as m, parseCliOptions as n, RelayClientToServerMessageSchema as o, ServerHelloMessageSchema as p, printHelp as r, RelayDescriptorSchema as s, LocalRelayMcpServer as t, RelayServerToClientMessageSchema as u, sanitizeName as v, RelayInvokeArgsSchema as w, DEFAULT_TOOL_INPUT_SCHEMA as x, CallToolRequestParamsSchema as y };
-//# sourceMappingURL=mcpRelayServer-BT1ct1Cc.mjs.map
+//# sourceMappingURL=mcpRelayServer-BxI6zEc2.mjs.map