@mcp-b/webmcp-local-relay 6.0.0 → 6.0.2

package/dist/{mcpRelayServer-DEgebuO2.mjs → mcpRelayServer-DkidP4o7.mjs}

@@ -2,9 +2,6 @@ import { z } from "zod/v4";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 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, ToolAnnotationsSchema, ToolSchema } from "@modelcontextprotocol/core";
 import { parseArgs } from "node:util";
 import { execFile } from "node:child_process";
@@ -17,60 +14,6 @@ function isTcpAddress(address) {
 }
 const DEFAULT_RELAY_PORT = 9333;
 const DEFAULT_RELAY_PORT_RANGE_END = 9348;
-const RELAY_PORT_CACHE_MAX_AGE_MS = 1440 * 60 * 1e3;
-const PersistedRelayPortSchema = z.object({
-	port: z.number().int().min(1).max(65535),
-	host: z.string().min(1),
-	updatedAt: z.string()
-});
-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, expectedHost) {
-	try {
-		const raw = await readFile(path, "utf8");
-		const parsed = PersistedRelayPortSchema.parse(JSON.parse(raw));
-		if (expectedHost && parsed.host !== expectedHost) return null;
-		const updatedAtMs = Date.parse(parsed.updatedAt);
-		if (!Number.isFinite(updatedAtMs) || Date.now() - updatedAtMs > RELAY_PORT_CACHE_MAX_AGE_MS) 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, 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
@@ -91,7 +34,10 @@ const DEFAULT_TOOL_INPUT_SCHEMA = {
 	properties: {}
 };
 /** SDK tool schema with a browser-compatible default input schema. */
-const InboundToolSchema = NormalizedToolSchema.extend({ inputSchema: NormalizedToolSchema.shape.inputSchema.optional() });
+const InboundToolSchema = NormalizedToolSchema.extend({ inputSchema: z.looseObject({}).transform((schema) => ({
+	type: "object",
+	...schema
+})).pipe(NormalizedToolSchema.shape.inputSchema).optional() });
 /**
 * Applies the browser default input schema and validates the complete SDK tool.
 */
@@ -359,8 +305,17 @@ var RelayRegistry = class {
 
 //#endregion
 //#region src/schemas.ts
-function normalizeSupportedInboundTools(tools) {
-	return tools.map(normalizeInboundTool).filter((tool) => tool.execution?.taskSupport !== "required");
+/** Parses each tool on its own, so one malformed tool does not hide the page's other tools. */
+function parseBrowserTools(tools) {
+	return tools.flatMap((raw) => {
+		const parsed = InboundToolSchema.safeParse(raw);
+		if (!parsed.success) {
+			process.stderr.write(`[webmcp-local-relay] warn: skipped a malformed page tool: ${parsed.error.message}\n`);
+			return [];
+		}
+		const tool = normalizeInboundTool(parsed.data);
+		return tool.execution?.taskSupport === "required" ? [] : [tool];
+	});
 }
 const BrowserHelloMessageSchema = z.object({
 	type: z.literal("hello"),
@@ -372,11 +327,11 @@ const BrowserHelloMessageSchema = z.object({
 });
 const BrowserToolsListMessageSchema = z.object({
 	type: z.literal("tools/list"),
-	tools: z.array(InboundToolSchema).transform(normalizeSupportedInboundTools)
+	tools: z.array(z.unknown()).transform(parseBrowserTools)
 });
 const BrowserToolsChangedMessageSchema = z.object({
 	type: z.literal("tools/changed"),
-	tools: z.array(InboundToolSchema).transform(normalizeSupportedInboundTools)
+	tools: z.array(z.unknown()).transform(parseBrowserTools)
 });
 const BrowserToolResultMessageSchema = z.object({
 	type: z.literal("result"),
@@ -431,6 +386,10 @@ const RelayInvokeMessageSchema = z.object({
 	toolName: z.string().min(1),
 	args: RelayInvokeArgsSchema
 });
+const RelayCancelMessageSchema = z.object({
+	type: z.literal("cancel"),
+	callId: z.string().min(1)
+});
 const RelayPingMessageSchema = z.object({ type: z.literal("ping") });
 const RelayReloadMessageSchema = z.object({ type: z.literal("reload") });
 /**
@@ -441,6 +400,7 @@ const RelayToBrowserMessageSchema = z.discriminatedUnion("type", [
 	RelayHelloAcceptedMessageSchema,
 	RelayHelloRejectedMessageSchema,
 	RelayInvokeMessageSchema,
+	RelayCancelMessageSchema,
 	RelayPingMessageSchema,
 	RelayReloadMessageSchema
 ]);
@@ -466,13 +426,18 @@ const RelayClientInvokeSchema = z.object({
 	toolName: z.string().min(1),
 	args: RelayInvokeArgsSchema
 });
+const RelayClientCancelSchema = z.object({
+	type: z.literal("relay/cancel"),
+	callId: z.string().min(1)
+});
 /**
 * Union schema for all relay-client-to-server messages.
 */
 const RelayClientToServerMessageSchema = z.discriminatedUnion("type", [
 	RelayClientHelloSchema,
 	RelayClientListToolsSchema,
-	RelayClientInvokeSchema
+	RelayClientInvokeSchema,
+	RelayClientCancelSchema
 ]);
 const RelayToolsPayloadFields = {
 	tools: z.array(NormalizedToolSchema),
@@ -507,7 +472,11 @@ const RelayServerToClientMessageSchema = z.discriminatedUnion("type", [
 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;
+/**
+* How long a joining relay waits for the relay on a port to greet it. Too short, and a busy
+* relay is mistaken for another service, so a second relay starts and splits pages from clients.
+*/
+const RELAY_SERVER_MESSAGE_TIMEOUT_MS = 5e3;
 const HEARTBEAT_INTERVAL_MS = 15e3;
 const HEARTBEAT_DEAD_THRESHOLD_MS = 25e3;
 const RawMessageTypeSchema = z.object({ type: z.unknown().optional() });
@@ -541,7 +510,6 @@ var RelayBridgeServer = class extends EventEmitter {
 	desiredPort;
 	portExplicitlySet;
 	portRangeEnd;
-	persistPath;
 	allowedOrigins;
 	maxPayloadBytes;
 	invokeTimeoutMs;
@@ -555,6 +523,7 @@ var RelayBridgeServer = class extends EventEmitter {
 	pendingInvocations = /* @__PURE__ */ new Map();
 	browserClientConnectionIds = /* @__PURE__ */ new Set();
 	relayClientConnectionIds = /* @__PURE__ */ new Set();
+	relayClientInvocations = /* @__PURE__ */ new Map();
 	heartbeatIntervalByConnectionId = /* @__PURE__ */ new Map();
 	lastPongByConnectionId = /* @__PURE__ */ new Map();
 	onStateChangedPushRelay = () => {
@@ -568,8 +537,6 @@ var RelayBridgeServer = class extends EventEmitter {
 	* Maximum delay for relay-to-relay reconnection backoff in client mode.
 	*/
 	clientMaxReconnectDelay = 3e3;
-	clientMaxReconnectAttempts = 100;
-	clientReconnectAttempts = 0;
 	clientPendingInvocations = /* @__PURE__ */ new Map();
 	clientTools = [];
 	clientSources = [];
@@ -586,7 +553,6 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.desiredPort = this.preferredPort;
 		this.portExplicitlySet = options.portExplicitlySet ?? false;
 		this.portRangeEnd = options.portRangeEnd ?? Math.max(9348, this.preferredPort);
-		this.persistPath = options.persistPath ?? defaultRelayPortPersistPath();
 		this.allowedOrigins = options.allowedOrigins ?? ["*"];
 		this.maxPayloadBytes = options.maxPayloadBytes ?? 1e7;
 		this.invokeTimeoutMs = options.invokeTimeoutMs ?? 65e3;
@@ -649,39 +615,21 @@ var RelayBridgeServer = class extends EventEmitter {
 			await this.startAsServer(0);
 			return;
 		}
-		const strategyOptions = {
-			defaultPort: this.preferredPort,
-			host: this.host,
-			persistPath: this.persistPath,
-			rangeEnd: this.portRangeEnd
-		};
-		if (this.portExplicitlySet) strategyOptions.fixedPort = this.preferredPort;
-		const candidates = await buildPortCandidates(strategyOptions);
-		for (const candidate of candidates) try {
-			await this.startAsServer(candidate.port);
-			await this.persistSelectedPort();
+		const lastPort = this.portExplicitlySet ? this.preferredPort : this.portRangeEnd;
+		for (let port = this.preferredPort; port <= lastPort; port++) try {
+			await this.startAsServer(port);
 			return;
 		} catch (err) {
 			if (!this.isAddressInUseError(err)) throw err;
-			if (await this.tryAttachToExistingRelay(candidate.port)) {
-				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.`);
-			process.stderr.write(`[webmcp-local-relay] info: port ${candidate.port} is occupied by a non-relay service, trying next port\n`);
+			if (await this.tryAttachToExistingRelay(port)) return;
+			if (this.portExplicitlySet) throw new Error(`Port ${port} is already in use by a non-WebMCP service and cannot be shared.`);
+			process.stderr.write(`[webmcp-local-relay] info: port ${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(cause) {
 		return cause instanceof Error && ("code" in cause ? cause.code === "EADDRINUSE" : cause.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);
@@ -702,11 +650,7 @@ var RelayBridgeServer = class extends EventEmitter {
 			this.clientReconnectTimer = null;
 		}
 		if (this._mode === "client") {
-			for (const pending of this.clientPendingInvocations.values()) {
-				clearTimeout(pending.timeoutId);
-				pending.reject(/* @__PURE__ */ new Error("Relay client stopped"));
-			}
-			this.clientPendingInvocations.clear();
+			for (const pending of this.clientPendingInvocations.values()) pending.cancel(/* @__PURE__ */ new Error("Relay client stopped"));
 			this.clientTools = [];
 			this.clientSources = [];
 			this.clientToolSourceMap = {};
@@ -721,6 +665,9 @@ var RelayBridgeServer = class extends EventEmitter {
 			return;
 		}
 		this.off("stateChanged", this.onStateChangedPushRelay);
+		for (const pending of this.pendingInvocations.values()) pending.cancel(/* @__PURE__ */ new Error("Relay server stopped before tool invocation completed"));
+		for (const invocations of this.relayClientInvocations.values()) for (const controller of invocations.values()) controller.abort();
+		this.relayClientInvocations.clear();
 		for (const [connectionId, socket] of this.socketByConnectionId) {
 			this.registry.removeConnection(connectionId);
 			try {
@@ -736,20 +683,19 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.requestOriginByConnectionId.clear();
 		this.browserClientConnectionIds.clear();
 		this.relayClientConnectionIds.clear();
-		for (const pending of this.pendingInvocations.values()) {
-			clearTimeout(pending.timeoutId);
-			pending.reject(/* @__PURE__ */ new Error("Relay server stopped before tool invocation completed"));
-		}
-		this.pendingInvocations.clear();
 		const wss = this.wss;
 		this.wss = null;
 		if (!wss) return;
+		const lingering = setTimeout(() => {
+			for (const client of wss.clients) client.terminate();
+		}, 500);
 		await new Promise((resolve) => {
 			wss.close((err) => {
 				if (err) process.stderr.write(`[webmcp-local-relay] warn: WebSocket server close error: ${err.message}\n`);
 				resolve();
 			});
 		});
+		clearTimeout(lingering);
 	}
 	/**
 	* Sends a reload message to a connected browser source.
@@ -771,7 +717,8 @@ var RelayBridgeServer = class extends EventEmitter {
 	* (client mode).
 	*/
 	async invokeTool(toolName, args, options = {}) {
-		if (this._mode === "client") return this.invokeToolViaRelay(toolName, args);
+		options.signal?.throwIfAborted();
+		if (this._mode === "client") return this.invokeToolViaRelay(toolName, args, options.signal);
 		return this.invokeToolLocally(toolName, args, options);
 	}
 	async startAsServer(port = this.desiredPort) {
@@ -861,32 +808,12 @@ var RelayBridgeServer = class extends EventEmitter {
 		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}"`);
-		const callId = randomUUID();
-		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.pendingInvocations.delete(callId);
-				reject(/* @__PURE__ */ new Error(`Invocation for tool "${toolName}" timed out after ${this.invokeTimeoutMs}ms`));
-			}, this.invokeTimeoutMs);
-			this.pendingInvocations.set(callId, {
-				connectionId: resolved.connectionId,
-				timeoutId,
-				resolve,
-				reject
-			});
-			const message = {
-				type: "invoke",
-				callId,
-				toolName: resolved.tool.name,
-				args
-			};
-			try {
-				socket.send(JSON.stringify(message));
-			} catch (err) {
-				clearTimeout(timeoutId);
-				this.pendingInvocations.delete(callId);
-				reject(/* @__PURE__ */ new Error(`Failed to send invocation for tool "${toolName}": ${err instanceof Error ? err.message : err}`));
-			}
-		});
+		return this.requestTool(socket, this.pendingInvocations, resolved.connectionId, {
+			type: "invoke",
+			callId: randomUUID(),
+			toolName: resolved.tool.name,
+			args
+		}, `Invocation for tool "${toolName}" timed out after ${this.invokeTimeoutMs}ms`, options.signal);
 	}
 	/** Handles a raw message according to the negotiated WebSocket protocol. */
 	onSocketMessage(connectionId, raw) {
@@ -970,8 +897,6 @@ var RelayBridgeServer = class extends EventEmitter {
 					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));
 				break;
 			}
@@ -1004,15 +929,33 @@ var RelayBridgeServer = class extends EventEmitter {
 			}
 			case "relay/invoke": {
 				const { callId, toolName, args } = message;
-				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
-				}));
+				let invocations = this.relayClientInvocations.get(connectionId);
+				if (!invocations) {
+					invocations = /* @__PURE__ */ new Map();
+					this.relayClientInvocations.set(connectionId, invocations);
+				}
+				if (invocations.has(callId)) break;
+				const controller = new AbortController();
+				invocations.set(callId, controller);
+				this.invokeToolLocally(toolName, args ?? {}, { signal: controller.signal }).then((result) => {
+					if (!controller.signal.aborted) this.sendRelayResult(connectionId, callId, result);
+				}, (error) => {
+					if (!controller.signal.aborted) this.sendRelayResult(connectionId, callId, {
+						content: [{
+							type: "text",
+							text: `Relay invocation failed: ${error instanceof Error ? error.message : String(error)}`
+						}],
+						isError: true
+					});
+				}).finally(() => {
+					invocations.delete(callId);
+					if (invocations.size === 0) this.relayClientInvocations.delete(connectionId);
+				});
 				break;
 			}
+			case "relay/cancel":
+				this.relayClientInvocations.get(connectionId)?.get(message.callId)?.abort();
+				break;
 		}
 	}
 	sendRelayResult(connectionId, callId, result) {
@@ -1059,14 +1002,14 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.requestOriginByConnectionId.delete(connectionId);
 		this.browserClientConnectionIds.delete(connectionId);
 		this.relayClientConnectionIds.delete(connectionId);
+		for (const controller of this.relayClientInvocations.get(connectionId)?.values() ?? []) controller.abort();
+		this.relayClientInvocations.delete(connectionId);
 		this.registry.removeConnection(connectionId);
 		this.socketByConnectionId.delete(connectionId);
 		this.emit("stateChanged");
 		const isPayloadExceeded = code === 1009;
-		for (const [callId, pending] of this.pendingInvocations.entries()) {
+		for (const pending of this.pendingInvocations.values()) {
 			if (pending.connectionId !== connectionId) continue;
-			clearTimeout(pending.timeoutId);
-			this.pendingInvocations.delete(callId);
 			if (isPayloadExceeded) pending.reject(/* @__PURE__ */ new Error(`Tool result exceeded maximum payload size (${formatPayloadLimit(this.maxPayloadBytes)}). Use --max-payload to increase the limit.`));
 			else pending.reject(/* @__PURE__ */ new Error(`Tool source ${connectionId} disconnected during invocation`));
 		}
@@ -1084,7 +1027,7 @@ var RelayBridgeServer = class extends EventEmitter {
 			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");
+				socket.terminate();
 				return;
 			}
 			try {
@@ -1104,7 +1047,6 @@ var RelayBridgeServer = class extends EventEmitter {
 		this.lastPongByConnectionId.delete(connectionId);
 	}
 	async startAsClient(port = this.desiredPort) {
-		this.stopping = false;
 		const previousMode = this._mode;
 		const previousPort = this.desiredPort;
 		this._mode = "client";
@@ -1113,7 +1055,6 @@ var RelayBridgeServer = class extends EventEmitter {
 			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;
@@ -1194,11 +1135,7 @@ var RelayBridgeServer = class extends EventEmitter {
 		});
 		ws.on("close", () => {
 			this.clientSocket = null;
-			for (const [callId, pending] of this.clientPendingInvocations) {
-				clearTimeout(pending.timeoutId);
-				this.clientPendingInvocations.delete(callId);
-				pending.reject(/* @__PURE__ */ new Error("Relay server connection lost during invocation"));
-			}
+			for (const pending of this.clientPendingInvocations.values()) pending.reject(/* @__PURE__ */ new Error("Relay server connection lost during invocation"));
 			this.clientTools = [];
 			this.clientSources = [];
 			this.clientToolSourceMap = {};
@@ -1247,8 +1184,6 @@ var RelayBridgeServer = class extends EventEmitter {
 					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;
 			}
@@ -1256,11 +1191,6 @@ var RelayBridgeServer = class extends EventEmitter {
 	}
 	scheduleReconnect() {
 		if (this.clientReconnectTimer || this.stopping) return;
-		this.clientReconnectAttempts++;
-		if (this.clientReconnectAttempts >= this.clientMaxReconnectAttempts) {
-			process.stderr.write(`[webmcp-local-relay] error: giving up reconnection after ${this.clientReconnectAttempts} attempts\n`);
-			return;
-		}
 		const delay = this.clientReconnectDelay;
 		this.clientReconnectDelay = Math.min(this.clientReconnectDelay * 1.5, this.clientMaxReconnectDelay);
 		this.clientReconnectTimer = setTimeout(() => {
@@ -1276,8 +1206,11 @@ var RelayBridgeServer = class extends EventEmitter {
 	async reconnectWithModePromotion() {
 		try {
 			await this.startUsingPortStrategy();
+			if (this.stopping) {
+				await this.stop();
+				return;
+			}
 			this.clientReconnectDelay = 500;
-			this.clientReconnectAttempts = 0;
 			if (this._mode === "server") {
 				process.stderr.write("[webmcp-local-relay] info: promoted from client to server mode\n");
 				this.emit("stateChanged");
@@ -1287,33 +1220,59 @@ var RelayBridgeServer = class extends EventEmitter {
 			if (!this.stopping) this.scheduleReconnect();
 		}
 	}
-	async invokeToolViaRelay(toolName, args) {
+	async invokeToolViaRelay(toolName, args, signal) {
 		if (!this.clientSocket || this.clientSocket.readyState !== WebSocket.OPEN) throw new Error("Not connected to relay server");
-		const callId = randomUUID();
-		const socket = this.clientSocket;
+		return this.requestTool(this.clientSocket, this.clientPendingInvocations, "relay-server", {
+			type: "relay/invoke",
+			callId: randomUUID(),
+			toolName,
+			args
+		}, `Proxied invocation for tool "${toolName}" timed out after ${this.invokeTimeoutMs}ms`, signal);
+	}
+	requestTool(socket, invocations, connectionId, message, timeoutMessage, signal) {
+		signal?.throwIfAborted();
+		const { callId } = message;
 		return new Promise((resolve, reject) => {
 			const timeoutId = setTimeout(() => {
-				this.clientPendingInvocations.delete(callId);
-				reject(/* @__PURE__ */ new Error(`Proxied invocation for tool "${toolName}" timed out after ${this.invokeTimeoutMs}ms`));
+				pending.cancel(new Error(timeoutMessage));
 			}, this.invokeTimeoutMs);
-			this.clientPendingInvocations.set(callId, {
-				connectionId: "relay-server",
-				timeoutId,
-				resolve,
-				reject
-			});
-			const message = {
-				type: "relay/invoke",
-				callId,
-				toolName,
-				args
+			const onAbort = () => pending.cancel(signal?.reason);
+			const cleanup = () => {
+				if (!invocations.delete(callId)) return false;
+				clearTimeout(timeoutId);
+				signal?.removeEventListener("abort", onAbort);
+				return true;
 			};
+			const pending = {
+				connectionId,
+				resolve: (result) => {
+					if (cleanup()) resolve(result);
+				},
+				reject: (reason) => {
+					if (cleanup()) reject(reason);
+				},
+				cancel: (reason) => {
+					if (!cleanup()) return;
+					try {
+						if (socket.readyState === WebSocket.OPEN) {
+							const cancellation = {
+								type: message.type === "invoke" ? "cancel" : "relay/cancel",
+								callId
+							};
+							socket.send(JSON.stringify(cancellation));
+						}
+					} catch (error) {
+						process.stderr.write(`[webmcp-local-relay] warn: failed to cancel call ${callId}: ${error instanceof Error ? error.message : String(error)}\n`);
+					}
+					reject(reason);
+				}
+			};
+			invocations.set(callId, pending);
+			signal?.addEventListener("abort", onAbort, { once: true });
 			try {
 				socket.send(JSON.stringify(message));
 			} catch (err) {
-				clearTimeout(timeoutId);
-				this.clientPendingInvocations.delete(callId);
-				reject(/* @__PURE__ */ new Error(`Failed to send relay invocation: ${err instanceof Error ? err.message : err}`));
+				pending.reject(/* @__PURE__ */ new Error(`Failed to send invocation: ${err instanceof Error ? err.message : String(err)}`));
 			}
 		});
 	}
@@ -1435,11 +1394,11 @@ function parseCliOptions(argv) {
 		port,
 		portExplicitlySet: values.port !== void 0
 	};
-	if (values.label !== void 0) options.label = values.label;
+	if (values.label) options.label = values.label;
 	if (invokeTimeoutMs !== void 0) options.invokeTimeoutMs = invokeTimeoutMs;
 	if (maxPayloadBytes !== void 0) options.maxPayloadBytes = maxPayloadBytes;
-	if (values["relay-id"] !== void 0) options.relayId = values["relay-id"];
-	if (values.workspace !== void 0) options.workspace = values.workspace;
+	if (values["relay-id"]) options.relayId = values["relay-id"];
+	if (values.workspace) options.workspace = values.workspace;
 	return options;
 }
 /**
@@ -1471,6 +1430,12 @@ function printHelp() {
 //#endregion
 //#region src/mcpRelayServer.ts
 const JsonSchemaObjectSchema = z.record(z.string(), z.unknown());
+/** Tools the relay registers itself, matching `registerStaticTools`. */
+const RELAY_TOOL_NAMES = new Set([
+	"webmcp_list_sources",
+	"webmcp_list_tools",
+	"webmcp_open_page"
+]);
 function textResult(text) {
 	return { content: [{
 		type: "text",
@@ -1497,6 +1462,8 @@ var LocalRelayMcpServer = class {
 	mcpServer;
 	launchBrowser;
 	dynamicTools = /* @__PURE__ */ new Map();
+	/** Page tools that share a name with a relay tool, already reported once. */
+	shadowedToolNames = /* @__PURE__ */ new Set();
 	syncDebounceTimer = null;
 	connected = false;
 	/**
@@ -1720,6 +1687,13 @@ var LocalRelayMcpServer = class {
 			this.dynamicTools.delete(name);
 		}
 		for (const tool of tools) {
+			if (RELAY_TOOL_NAMES.has(tool.name)) {
+				if (!this.shadowedToolNames.has(tool.name)) {
+					this.shadowedToolNames.add(tool.name);
+					process.stderr.write(`[webmcp-local-relay] warn: skipped page tool "${tool.name}" because a built-in relay tool has that name\n`);
+				}
+				continue;
+			}
 			const signature = this.toolSignature(tool);
 			const current = this.dynamicTools.get(tool.name);
 			if (current?.signature === signature) continue;
@@ -1754,10 +1728,11 @@ var LocalRelayMcpServer = class {
 		if (tool.annotations) registration.annotations = tool.annotations;
 		if (tool.icons) registration.icons = tool.icons;
 		if (tool._meta) registration._meta = tool._meta;
-		return this.mcpServer.registerTool(tool.name, registration, async (args) => {
+		return this.mcpServer.registerTool(tool.name, registration, async (args, context) => {
 			try {
-				return await this.bridge.invokeTool(tool.name, args);
+				return await this.bridge.invokeTool(tool.name, args, { signal: context.mcpReq.signal });
 			} catch (err) {
+				if (context.mcpReq.signal.aborted) throw err;
 				const message = err instanceof Error ? err.message : String(err);
 				const details = err instanceof Error ? err.stack ?? err.message : String(err);
 				process.stderr.write(`[webmcp-local-relay] error: dynamic tool "${tool.name}" invocation failed: ${details}\n`);
@@ -1800,4 +1775,4 @@ var LocalRelayMcpServer = class {
 
 //#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-DEgebuO2.mjs.map
+//# sourceMappingURL=mcpRelayServer-DkidP4o7.mjs.map