@modelcontextprotocol/inspector 2.13.0 → 2.14.0

package/clients/cli/build/index.js

@@ -18,7 +18,7 @@ import nodeFs, { existsSync, readFileSync, rmdirSync, statSync } from "node:fs";
 import properLockfile from "proper-lockfile";
 import * as crypto$1 from "node:crypto";
 import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { bodyLimit } from "hono/body-limit";
@@ -32,7 +32,10 @@ import { bindTaskReceiver } from "@modelcontextprotocol/ext-tasks/receiver";
 import { runtimeCodecFromStandardSchema, taskId, toJsonValue } from "@modelcontextprotocol/ext-tasks/core";
 import { TASKS_EXTENSION_ID_V2 as TASKS_EXTENSION_KEY } from "@modelcontextprotocol/ext-tasks/core/v2";
 import { RESOURCE_MIME_TYPE, getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
-import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
+import Ajv from "ajv";
+import { Ajv2019 } from "ajv/dist/2019.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { addFormats } from "@modelcontextprotocol/client/validators/ajv";
 import { createServer } from "node:http";
 import open from "open";
 import { createInterface } from "node:readline/promises";
@@ -5114,7 +5117,8 @@ const EXIT_CODES = {
 	SKILL_INCOMPLETE: 8,
 	SKILL_UNVERIFIABLE: 9,
 	LOAD_THRESHOLD_EXCEEDED: 10,
-	RATE_LIMITED: 11
+	RATE_LIMITED: 11,
+	INTERRUPTED: 130
 };
 function rateLimitFieldsOf(error) {
 	const data = error?.data;
@@ -7048,26 +7052,37 @@ function expectedSecretFields(stored) {
 	if (isStdioStored(stored) && stored.env) for (const k of Object.keys(stored.env)) fields.push(envSecretField(k));
 	return fields;
 }
-const DEFAULT_SEED_CONFIG = { mcpServers: {
-	"filesystem-server-default": {
-		type: "stdio",
-		command: "npx",
-		args: [
-			"-y",
-			"@modelcontextprotocol/server-filesystem",
-			"/tmp"
-		]
-	},
-	"everything-server-default": {
-		type: "stdio",
-		command: "npx",
-		args: ["-y", "@modelcontextprotocol/server-everything"]
-	},
-	"example-server-default": {
-		type: "streamable-http",
-		url: "https://example-server.modelcontextprotocol.io/mcp"
+const EXAMPLE_SERVER_URL = "https://example-server.modelcontextprotocol.io/mcp";
+function adHocServerName(config) {
+	if (config.type === "sse" || config.type === "streamable-http") try {
+		return new URL(config.url).host || "server";
+	} catch {
+		return "server";
 	}
-} };
+	return config.command?.split(/[\\/]/).pop() || "server";
+}
+function defaultSeedConfig(tempDir) {
+	return { mcpServers: {
+		"filesystem-server-default": {
+			type: "stdio",
+			command: "npx",
+			args: [
+				"-y",
+				"@modelcontextprotocol/server-filesystem",
+				tempDir
+			]
+		},
+		"everything-server-default": {
+			type: "stdio",
+			command: "npx",
+			args: ["-y", "@modelcontextprotocol/server-everything"]
+		},
+		"example-server-default": {
+			type: "streamable-http",
+			url: EXAMPLE_SERVER_URL
+		}
+	} };
+}
 //#endregion
 //#region ../../core/mcp/import/clientConfig.ts
 function parseJsonObject(raw) {
@@ -7202,9 +7217,13 @@ function waitForProgressToken(waits, token) {
 //#endregion
 //#region ../../core/mcp/remote/node/remote-session.ts
 var RemoteSession = class RemoteSession {
+	static DEFAULT_DETACH_GRACE_MS = 6e4;
+	static MAX_QUEUED_EVENTS = 1e3;
 	sessionId;
 	transport;
 	eventQueue = [];
+	droppedEventCount = 0;
+	detachTimer;
 	eventConsumer = null;
 	transportDead = false;
 	transportError = null;
@@ -7235,13 +7254,47 @@ var RemoteSession = class RemoteSession {
 		this.transport.setProtocolVersion?.(version);
 	}
 	setEventConsumer(consumer) {
+		this.cancelDetachGrace();
 		this.eventConsumer = consumer;
+		if (this.droppedEventCount > 0) {
+			const dropped = this.droppedEventCount;
+			this.droppedEventCount = 0;
+			consumer({
+				type: "stdio_log",
+				data: {
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					message: `[inspector] ${dropped} event(s) were dropped while no client was attached (the queue holds at most ${RemoteSession.MAX_QUEUED_EVENTS})`
+				}
+			});
+		}
 		while (this.eventQueue.length > 0) consumer(this.eventQueue.shift());
 	}
 	clearEventConsumer() {
 		this.eventConsumer = null;
 		return this.transportDead;
 	}
+	detachEventConsumer(consumer) {
+		if (this.eventConsumer !== consumer) return false;
+		this.eventConsumer = null;
+		return true;
+	}
+	armDetachGrace(graceMs, onExpire) {
+		this.cancelDetachGrace();
+		this.detachTimer = setTimeout(() => {
+			this.detachTimer = void 0;
+			onExpire();
+		}, graceMs);
+		this.detachTimer.unref();
+	}
+	cancelDetachGrace() {
+		if (this.detachTimer !== void 0) {
+			clearTimeout(this.detachTimer);
+			this.detachTimer = void 0;
+		}
+	}
+	hasPendingDetachGrace() {
+		return this.detachTimer !== void 0;
+	}
 	markTransportDead(error) {
 		this.transportDead = true;
 		this.transportError = error;
@@ -7352,7 +7405,13 @@ var RemoteSession = class RemoteSession {
 	}
 	pushEvent(event) {
 		if (this.eventConsumer) this.eventConsumer(event);
-		else this.eventQueue.push(event);
+		else {
+			if (this.eventQueue.length >= RemoteSession.MAX_QUEUED_EVENTS) {
+				this.eventQueue.shift();
+				this.droppedEventCount++;
+			}
+			this.eventQueue.push(event);
+		}
 	}
 	onMessage(message) {
 		if ("id" in message && message.id !== null && message.id !== void 0 && ("result" in message || "error" in message)) this.settleRequestWait(message.id);
@@ -7832,6 +7891,14 @@ function createRemoteApp(options) {
 	const authToken = dangerouslyOmitAuth ? "" : options.authToken || process.env[API_SERVER_ENV_VARS.AUTH_TOKEN] || randomBytes(32).toString("hex");
 	const app = new Hono();
 	const sessions = /* @__PURE__ */ new Map();
+	const sessionDetachGraceMs = options.sessionDetachGraceMs ?? RemoteSession.DEFAULT_DETACH_GRACE_MS;
+	const armSessionReap = (session) => {
+		session.armDetachGrace(sessionDetachGraceMs, () => {
+			sessions.delete(session.sessionId);
+			session.rejectActiveRequestWaits(/* @__PURE__ */ new Error("Session closed: no client attached"));
+			session.transport.close().catch(() => {});
+		});
+	};
 	const { logger: fileLogger, allowedOrigins } = options;
 	const storageDir = options.storageDir ?? getDefaultStorageDir();
 	const mcpConfigPath = options.mcpConfigPath ?? getDefaultMcpConfigPath();
@@ -8018,6 +8085,7 @@ function createRemoteApp(options) {
 			return c.json({ error: `Failed to start transport: ${msg}` }, is401 ? 401 : 500);
 		}
 		sessions.set(sessionId, session);
+		armSessionReap(session);
 		return c.json({ sessionId });
 	});
 	app.post("/api/mcp/send", async (c) => {
@@ -8108,13 +8176,14 @@ function createRemoteApp(options) {
 		const session = sessions.get(sessionId);
 		if (!session) return c.json({ error: "Session not found" }, 404);
 		return streamSSE(c, async (stream) => {
-			session.setEventConsumer((event) => {
+			const consumer = (event) => {
 				const data = JSON.stringify(event);
 				stream.writeSSE({
 					event: event.type,
 					data
 				});
-			});
+			};
+			session.setEventConsumer(consumer);
 			if (session.isTransportDead()) {
 				await new Promise((resolve) => setTimeout(resolve, 0));
 				session.clearEventConsumer();
@@ -8122,7 +8191,12 @@ function createRemoteApp(options) {
 				return;
 			}
 			await primeAndHoldSseStream(stream, () => {
-				if (session.clearEventConsumer() || session.isTransportDead()) sessions.delete(sessionId);
+				if (!session.detachEventConsumer(consumer)) return;
+				if (session.isTransportDead()) {
+					sessions.delete(sessionId);
+					return;
+				}
+				armSessionReap(session);
 			});
 		});
 	});
@@ -8137,6 +8211,7 @@ function createRemoteApp(options) {
 		if (!sessionId) return c.json({ error: "Missing sessionId" }, 400);
 		const session = sessions.get(sessionId);
 		if (session) {
+			session.cancelDetachGrace();
 			session.clearEventConsumer();
 			await session.transport.close();
 			sessions.delete(sessionId);
@@ -8800,8 +8875,9 @@ function createRemoteApp(options) {
 			const settled = await withWriteLock(async () => {
 				const rawInside = await readStoreFile(mcpConfigPath);
 				if (rawInside === null) {
-					await writeMcpAndTrackMtime(serializeStore(DEFAULT_SEED_CONFIG));
-					return DEFAULT_SEED_CONFIG;
+					const seed = defaultSeedConfig(tmpdir());
+					await writeMcpAndTrackMtime(serializeStore(seed));
+					return seed;
 				}
 				const parsedInside = parseStore(rawInside);
 				const inside = { mcpServers: normalizeMcpServers(parsedInside?.mcpServers) };
@@ -9356,8 +9432,9 @@ async function loadServerEntries(serverOptions) {
 	}
 	const configs = resolveServerConfigs(serverOptions, "multi");
 	if (configs.length === 0) throw new Error("At least one server is required. Use --catalog/--config <path> or an ad-hoc target (command/URL).");
-	return { default: {
-		config: configs[0],
+	const config = configs[0];
+	return { [adHocServerName(config)]: {
+		config,
 		settings: mergeSettings(void 0, serverOptions)
 	} };
 }
@@ -11177,6 +11254,627 @@ function validateToolOutput(provider, tool, result) {
 		return;
 	}
 }
+//#endregion
+//#region ../../core/json/linearRegExp.ts
+var CharMatcher = class {
+	re;
+	ascii = /* @__PURE__ */ new Uint8Array(128);
+	constructor(source, unicode) {
+		this.re = new RegExp(`^(?:${source})$`, unicode ? "u" : "");
+	}
+	matches(cp, unicode) {
+		if (cp < 128) {
+			const memo = this.ascii[cp];
+			if (memo !== 0) return memo === 1;
+			const result = this.re.test(String.fromCharCode(cp));
+			this.ascii[cp] = result ? 1 : 2;
+			return result;
+		}
+		return this.re.test(unicode ? String.fromCodePoint(cp) : String.fromCharCode(cp));
+	}
+};
+var Unsupported = class extends Error {};
+const MAX_GROUP_DEPTH = 64;
+const MAX_PROGRAM_SIZE = 1e4;
+const MAX_COMPILE_STEPS = 10 * MAX_PROGRAM_SIZE;
+const MAX_PATTERN_LENGTH = 8192;
+const COMPILE_BUDGET_EXHAUSTED = "the patterns together exceed the compilation budget";
+function isCompileBudgetExhausted(budget) {
+	return budget.steps < 0 || budget.size < 0;
+}
+const QUANTIFIER_BRACES = /\{(\d+)(?:(,)(\d*))?\}/y;
+const HEX4 = /^[0-9a-fA-F]{4}$/;
+const HEX2 = /^[0-9a-fA-F]{2}$/;
+var Parser = class {
+	pos = 0;
+	src;
+	unicode;
+	constructor(src, unicode) {
+		this.src = src;
+		this.unicode = unicode;
+	}
+	parse() {
+		const node = this.parseAlternation(0);
+		/* v8 ignore next -- the native RegExp constructor rejects an unbalanced `)` first */
+		if (this.pos !== this.src.length) throw new Unsupported("unbalanced group");
+		return node;
+	}
+	parseAlternation(depth) {
+		const options = [this.parseSequence(depth)];
+		while (this.src[this.pos] === "|") {
+			this.pos++;
+			options.push(this.parseSequence(depth));
+		}
+		return options.length === 1 ? options[0] : {
+			kind: "alt",
+			options
+		};
+	}
+	parseSequence(depth) {
+		const items = [];
+		while (this.pos < this.src.length && this.src[this.pos] !== "|" && this.src[this.pos] !== ")") items.push(this.parseTerm(depth));
+		return items.length === 1 ? items[0] : {
+			kind: "seq",
+			items
+		};
+	}
+	parseTerm(depth) {
+		const atom = this.parseAtom(depth);
+		const quantifier = this.readQuantifier();
+		if (!quantifier) return atom;
+		if (this.src[this.pos] === "?") this.pos++;
+		return {
+			kind: "repeat",
+			body: atom,
+			...quantifier
+		};
+	}
+	readQuantifier() {
+		const c = this.src[this.pos];
+		if (c === "*") {
+			this.pos++;
+			return {
+				min: 0,
+				max: Infinity
+			};
+		}
+		if (c === "+") {
+			this.pos++;
+			return {
+				min: 1,
+				max: Infinity
+			};
+		}
+		if (c === "?") {
+			this.pos++;
+			return {
+				min: 0,
+				max: 1
+			};
+		}
+		if (c === "{") {
+			QUANTIFIER_BRACES.lastIndex = this.pos;
+			const m = QUANTIFIER_BRACES.exec(this.src);
+			if (!m) return void 0;
+			this.pos += m[0].length;
+			const min = Number(m[1]);
+			return {
+				min,
+				max: m[2] === void 0 ? min : m[3] ? Number(m[3]) : Infinity
+			};
+		}
+	}
+	parseAtom(depth) {
+		switch (this.src[this.pos]) {
+			case "(": return this.parseGroup(depth);
+			case "[": return this.parseClass();
+			case "\\": return this.parseEscape();
+			case ".":
+				this.pos++;
+				return {
+					kind: "char",
+					source: "."
+				};
+			case "^":
+				this.pos++;
+				return {
+					kind: "assert",
+					assertion: "start"
+				};
+			case "$":
+				this.pos++;
+				return {
+					kind: "assert",
+					assertion: "end"
+				};
+			case "*":
+			case "+":
+			case "?":
+ /* v8 ignore next -- "nothing to repeat" is a native syntax error */
+			throw new Unsupported("nothing to repeat");
+			case "{":
+				QUANTIFIER_BRACES.lastIndex = this.pos;
+				if (QUANTIFIER_BRACES.test(this.src))
+ /* v8 ignore next -- rejected by the native RegExp constructor first */
+				throw new Unsupported("nothing to repeat");
+				this.pos++;
+				return {
+					kind: "char",
+					source: "\\{"
+				};
+			default: {
+				const width = this.codePointWidth(this.pos);
+				const source = this.src.slice(this.pos, this.pos + width);
+				this.pos += width;
+				return {
+					kind: "char",
+					source
+				};
+			}
+		}
+	}
+	codePointWidth(at) {
+		if (!this.unicode) return 1;
+		return this.src.codePointAt(at) > 65535 ? 2 : 1;
+	}
+	parseGroup(depth) {
+		if (depth >= MAX_GROUP_DEPTH) throw new Unsupported("groups nested too deeply");
+		this.pos++;
+		if (this.src.startsWith("?:", this.pos)) this.pos += 2;
+		else if (this.src.startsWith("?<", this.pos) && this.src[this.pos + 2] !== "=" && this.src[this.pos + 2] !== "!") {
+			const close = this.src.indexOf(">", this.pos);
+			/* v8 ignore next -- an unterminated group name is a native syntax error */
+			if (close < 0) throw new Unsupported("unterminated group name");
+			this.pos = close + 1;
+		} else if (this.src[this.pos] === "?") throw new Unsupported("lookaround or group modifier");
+		const body = this.parseAlternation(depth + 1);
+		/* v8 ignore next -- an unterminated group is a native syntax error */
+		if (this.src[this.pos] !== ")") throw new Unsupported("unterminated group");
+		this.pos++;
+		return body;
+	}
+	parseClass() {
+		const start = this.pos;
+		this.pos++;
+		while (this.pos < this.src.length && this.src[this.pos] !== "]") this.pos += this.src[this.pos] === "\\" ? 2 : 1;
+		/* v8 ignore next -- an unterminated class is a native syntax error */
+		if (this.pos >= this.src.length) throw new Unsupported("unterminated class");
+		this.pos++;
+		return {
+			kind: "char",
+			source: this.src.slice(start, this.pos)
+		};
+	}
+	parseEscape() {
+		const next = this.src[this.pos + 1];
+		/* v8 ignore next -- a trailing backslash is a native syntax error */
+		if (next === void 0) throw new Unsupported("trailing backslash");
+		switch (next) {
+			case "b":
+				this.pos += 2;
+				return {
+					kind: "assert",
+					assertion: "wordBoundary"
+				};
+			case "B":
+				this.pos += 2;
+				return {
+					kind: "assert",
+					assertion: "notWordBoundary"
+				};
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "6":
+			case "7":
+			case "8":
+			case "9":
+			case "k": throw new Unsupported("backreference");
+			case "0":
+				if (/[0-9]/.test(this.src[this.pos + 2] ?? "")) throw new Unsupported("octal escape");
+				return this.takeChar(2);
+			case "c":
+				if (!/[a-zA-Z]/.test(this.src[this.pos + 2] ?? "")) throw new Unsupported("incomplete control escape");
+				return this.takeChar(3);
+			case "p":
+			case "P":
+				if (this.unicode && this.src[this.pos + 2] === "{") return this.takeThrough("}");
+				return this.takeChar(2);
+			case "x": return this.takeChar(HEX2.test(this.src.slice(this.pos + 2, this.pos + 4)) ? 4 : 2);
+			case "u": return this.parseUnicodeEscape();
+			default: return this.takeChar(1 + this.codePointWidth(this.pos + 1));
+		}
+	}
+	parseUnicodeEscape() {
+		if (this.unicode && this.src[this.pos + 2] === "{") return this.takeThrough("}");
+		const hex = this.src.slice(this.pos + 2, this.pos + 6);
+		if (!HEX4.test(hex)) return this.takeChar(2);
+		const unit = parseInt(hex, 16);
+		if (this.unicode && unit >= 55296 && unit <= 56319 && this.src.startsWith("\\u", this.pos + 6)) {
+			const low = this.src.slice(this.pos + 8, this.pos + 12);
+			if (HEX4.test(low)) {
+				const lowUnit = parseInt(low, 16);
+				if (lowUnit >= 56320 && lowUnit <= 57343) return this.takeChar(12);
+			}
+		}
+		return this.takeChar(6);
+	}
+	takeChar(length) {
+		const source = this.src.slice(this.pos, this.pos + length);
+		this.pos += length;
+		return {
+			kind: "char",
+			source
+		};
+	}
+	takeThrough(terminator) {
+		const end = this.src.indexOf(terminator, this.pos);
+		/* v8 ignore next -- an unterminated `\p{` / `\u{` is a native syntax error */
+		if (end < 0) throw new Unsupported("unterminated escape");
+		return this.takeChar(end + 1 - this.pos);
+	}
+};
+var Compiler = class {
+	prog = [];
+	matchers = /* @__PURE__ */ new Map();
+	unicode;
+	budget;
+	steps = 0;
+	constructor(unicode, budget) {
+		this.unicode = unicode;
+		this.budget = budget;
+	}
+	emit(inst) {
+		if (this.prog.length >= 1e4) throw new Unsupported("pattern too complex");
+		if (this.budget && --this.budget.size < 0) throw new Unsupported(COMPILE_BUDGET_EXHAUSTED);
+		this.prog.push(inst);
+		return this.prog.length - 1;
+	}
+	matcher(source) {
+		let matcher = this.matchers.get(source);
+		if (!matcher) {
+			try {
+				matcher = new CharMatcher(source, this.unicode);
+			} catch {
+				/* v8 ignore start -- defensive: each atom is a slice the native constructor already accepted in context */
+				throw new Unsupported("unrecognized character syntax");
+			}
+			this.matchers.set(source, matcher);
+		}
+		return matcher;
+	}
+	compile(node) {
+		if (++this.steps > 1e5) throw new Unsupported("pattern too complex");
+		if (this.budget && --this.budget.steps < 0) throw new Unsupported(COMPILE_BUDGET_EXHAUSTED);
+		switch (node.kind) {
+			case "char":
+				this.emit({
+					op: "char",
+					matcher: this.matcher(node.source)
+				});
+				return;
+			case "assert":
+				this.emit({
+					op: "assert",
+					assertion: node.assertion
+				});
+				return;
+			case "seq":
+				for (const item of node.items) this.compile(item);
+				return;
+			case "alt":
+				this.compileAlternation(node.options);
+				return;
+			case "repeat":
+				this.compileRepeat(node.body, node.min, node.max);
+				return;
+		}
+	}
+	compileAlternation(options) {
+		const jumps = [];
+		for (let i = 0; i < options.length - 1; i++) {
+			const split = this.emit({
+				op: "split",
+				a: 0,
+				b: 0
+			});
+			this.patchSplit(split, split + 1, -1);
+			this.compile(options[i]);
+			jumps.push(this.emit({
+				op: "jmp",
+				to: 0
+			}));
+			this.patchSplit(split, -1, this.prog.length);
+		}
+		this.compile(options[options.length - 1]);
+		for (const jump of jumps) this.patchJump(jump, this.prog.length);
+	}
+	compileRepeat(body, min, max) {
+		for (let i = 0; i < min; i++) {
+			const before = this.prog.length;
+			this.compile(body);
+			if (this.prog.length === before) return;
+		}
+		if (max === Infinity) {
+			const split = this.emit({
+				op: "split",
+				a: 0,
+				b: 0
+			});
+			this.compile(body);
+			this.emit({
+				op: "jmp",
+				to: split
+			});
+			this.patchSplit(split, split + 1, this.prog.length);
+			return;
+		}
+		const splits = [];
+		for (let i = min; i < max; i++) {
+			const split = this.emit({
+				op: "split",
+				a: 0,
+				b: 0
+			});
+			this.patchSplit(split, split + 1, -1);
+			splits.push(split);
+			this.compile(body);
+		}
+		for (const split of splits) this.patchSplit(split, -1, this.prog.length);
+	}
+	patchSplit(at, a, b) {
+		const inst = this.prog[at];
+		if (a >= 0) inst.a = a;
+		if (b >= 0) inst.b = b;
+	}
+	patchJump(at, to) {
+		this.prog[at].to = to;
+	}
+};
+function isWordUnit(unit) {
+	return unit >= 48 && unit <= 57 || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122 || unit === 95;
+}
+var LinearRegExp = class {
+	anchoredStart;
+	prog;
+	unicode;
+	constructor(prog, unicode) {
+		this.prog = prog;
+		this.unicode = unicode;
+		const first = prog[0];
+		this.anchoredStart = first !== void 0 && first.op === "assert" && first.assertion === "start";
+	}
+	get size() {
+		return this.prog.length;
+	}
+	cost(input) {
+		return (input.length + 1) * this.prog.length;
+	}
+	search(input, budget) {
+		if (this.cost(input) > budget) return void 0;
+		const prog = this.prog;
+		const size = prog.length;
+		const mark = new Int32Array(size).fill(-1);
+		const stack = [];
+		let clist = new Int32Array(size);
+		let nlist = new Int32Array(size);
+		const add = (list, count, start, pos, generation) => {
+			stack.push(start);
+			while (stack.length > 0) {
+				const pc = stack.pop();
+				if (mark[pc] === generation) continue;
+				mark[pc] = generation;
+				const inst = prog[pc];
+				switch (inst.op) {
+					case "match":
+						stack.length = 0;
+						return -1;
+					case "jmp":
+						stack.push(inst.to);
+						break;
+					case "split":
+						stack.push(inst.b, inst.a);
+						break;
+					case "assert":
+						if (this.holds(inst.assertion, input, pos)) stack.push(pc + 1);
+						break;
+					case "char": list[count++] = pc;
+				}
+			}
+			return count;
+		};
+		let pos = 0;
+		let generation = 0;
+		let clen = add(clist, 0, 0, pos, generation);
+		if (clen < 0) return true;
+		while (pos < input.length) {
+			if (this.anchoredStart && clen === 0) return false;
+			const cp = this.unicode ? input.codePointAt(pos) : input.charCodeAt(pos);
+			const next = pos + (this.unicode && cp > 65535 ? 2 : 1);
+			generation++;
+			let nlen = 0;
+			for (let i = 0; i < clen; i++) {
+				const pc = clist[i];
+				if (prog[pc].matcher.matches(cp, this.unicode)) {
+					nlen = add(nlist, nlen, pc + 1, next, generation);
+					if (nlen < 0) return true;
+				}
+			}
+			nlen = add(nlist, nlen, 0, next, generation);
+			if (nlen < 0) return true;
+			[clist, nlist] = [nlist, clist];
+			clen = nlen;
+			pos = next;
+		}
+		return false;
+	}
+	holds(assertion, input, pos) {
+		switch (assertion) {
+			case "start": return pos === 0;
+			case "end": return pos === input.length;
+			case "wordBoundary":
+			case "notWordBoundary": return (pos > 0 && isWordUnit(input.charCodeAt(pos - 1))) !== (pos < input.length && isWordUnit(input.charCodeAt(pos))) === (assertion === "wordBoundary");
+		}
+	}
+};
+function compileLinearRegExp(pattern, unicode, budget) {
+	if (pattern.length > 8192) return {
+		ok: false,
+		reason: `pattern longer than ${MAX_PATTERN_LENGTH} characters`
+	};
+	if (budget) {
+		budget.steps -= pattern.length;
+		if (isCompileBudgetExhausted(budget)) return {
+			ok: false,
+			reason: COMPILE_BUDGET_EXHAUSTED
+		};
+	}
+	new RegExp(pattern, unicode ? "u" : "");
+	try {
+		const ast = new Parser(pattern, unicode).parse();
+		const compiler = new Compiler(unicode, budget);
+		compiler.compile(ast);
+		compiler.prog.push({ op: "match" });
+		return {
+			ok: true,
+			regExp: new LinearRegExp(compiler.prog, unicode)
+		};
+	} catch (error) {
+		/* v8 ignore next -- every throw inside the parser/compiler is an Unsupported */
+		if (!(error instanceof Unsupported)) throw error;
+		return {
+			ok: false,
+			reason: error.message
+		};
+	}
+}
+//#endregion
+//#region ../../core/mcp/linearPatternValidator.ts
+const PATTERN_EVALUATION_BUDGET = 2e7;
+const SCHEMA_COMPILE_BUDGET = {
+	steps: 10 * MAX_COMPILE_STEPS,
+	size: 10 * MAX_PROGRAM_SIZE
+};
+const MAX_QUOTED_PATTERN = 120;
+const DRAFT_2020_12 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
+const DRAFT_2019_09 = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2019-09/schema", "http://json-schema.org/draft/2019-09/schema"]);
+const DRAFT_07_OR_06 = /* @__PURE__ */ new Set([
+	"https://json-schema.org/draft-07/schema",
+	"http://json-schema.org/draft-07/schema",
+	"https://json-schema.org/draft-06/schema",
+	"http://json-schema.org/draft-06/schema"
+]);
+function declaredDialect(schema) {
+	const declared = schema.$schema;
+	if (typeof declared !== "string") return "2020-12";
+	const uri = declared.replace(/#$/, "");
+	if (DRAFT_2020_12.has(uri)) return "2020-12";
+	if (DRAFT_2019_09.has(uri)) return "2019-09";
+	if (DRAFT_07_OR_06.has(uri)) return "draft-7";
+	throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${declared.slice(0, 200)}"). Supported: JSON Schema 2020-12, 2019-09, draft-07, and draft-06.`);
+}
+function quote(pattern) {
+	return pattern.length > MAX_QUOTED_PATTERN ? `${pattern.slice(0, MAX_QUOTED_PATTERN)}…` : pattern;
+}
+var PatternLedger = class {
+	remaining = PATTERN_EVALUATION_BUDGET;
+	unevaluated = /* @__PURE__ */ new Set();
+	reset() {
+		this.remaining = PATTERN_EVALUATION_BUDGET;
+		this.unevaluated.clear();
+	}
+};
+var LinearPattern = class {
+	source;
+	flags;
+	compiled;
+	ledger;
+	constructor(source, flags, compiled, ledger) {
+		this.source = source;
+		this.flags = flags;
+		this.compiled = compiled;
+		this.ledger = ledger;
+	}
+	test(input) {
+		if (!this.compiled.ok) return this.skip(this.compiled.reason);
+		const { regExp } = this.compiled;
+		const cost = regExp.cost(input);
+		if (cost > this.ledger.remaining) return this.skip(`checking a ${input.length}-character value would exceed the evaluation budget`);
+		this.ledger.remaining -= cost;
+		return regExp.search(input, cost) === true;
+	}
+	skip(reason) {
+		this.ledger.unevaluated.add(`pattern "${quote(this.source)}" was not evaluated (${reason})`);
+		return true;
+	}
+	toString() {
+		return `/${this.source}/${this.flags}`;
+	}
+};
+function createRegExpEngine(ledger, budget) {
+	const engine = (pattern, flags) => new LinearPattern(pattern, flags, compileLinearRegExp(pattern, flags.includes("u"), budget()), ledger);
+	return Object.assign(engine, { code: "linearRegExp" });
+}
+var LinearPatternJsonSchemaValidator = class {
+	ledger = new PatternLedger();
+	engines = /* @__PURE__ */ new Map();
+	compileBudget = { ...SCHEMA_COMPILE_BUDGET };
+	overBudget = /* @__PURE__ */ new WeakSet();
+	engineFor(dialect) {
+		let engine = this.engines.get(dialect);
+		if (!engine) {
+			const options = {
+				strict: false,
+				validateFormats: true,
+				validateSchema: false,
+				allErrors: true,
+				code: { regExp: createRegExpEngine(this.ledger, () => this.compileBudget) }
+			};
+			engine = dialect === "2020-12" ? new Ajv2020(options) : dialect === "2019-09" ? new Ajv2019(options) : new Ajv(options);
+			addFormats(engine);
+			this.engines.set(dialect, engine);
+		}
+		return engine;
+	}
+	getValidator(schema) {
+		const engine = this.engineFor(declaredDialect(schema));
+		const id = schema.$id;
+		const validate = this.tracked(() => (typeof id === "string" ? engine.getSchema(id) : void 0) ?? engine.compile(schema));
+		const overBudget = this.overBudget.has(validate);
+		return (input) => {
+			this.ledger.reset();
+			const valid = validate(input);
+			const unevaluated = [...this.ledger.unevaluated];
+			if (overBudget) unevaluated.unshift("the schema's patterns exceed the compilation budget");
+			if (valid && unevaluated.length === 0) return {
+				valid: true,
+				data: input,
+				errorMessage: void 0
+			};
+			const messages = valid ? [] : [engine.errorsText(validate.errors)];
+			if (unevaluated.length > 0) messages.push(`${unevaluated.join("; ")}, so the value could not be verified against the schema`);
+			return {
+				valid: false,
+				data: void 0,
+				errorMessage: messages.join("; ")
+			};
+		};
+	}
+	tracked(run) {
+		const outer = this.compileBudget;
+		const budget = { ...SCHEMA_COMPILE_BUDGET };
+		this.compileBudget = budget;
+		try {
+			const validate = run();
+			if (isCompileBudgetExhausted(budget)) this.overBudget.add(validate);
+			return validate;
+		} finally {
+			this.compileBudget = outer;
+		}
+	}
+};
 function listPaginationExceeded(method) {
 	return /* @__PURE__ */ new Error(`Salvage walk for ${method} exceeded 64 pages without the server's pagination converging`);
 }
@@ -12923,6 +13621,16 @@ var RemoteClientTransport = class {
 		}
 		return await res.json();
 	}
+	releaseOnPageHide() {
+		if (!this._sessionId) return false;
+		this.fetchFn(`${this.baseUrl}/api/mcp/disconnect`, {
+			method: "POST",
+			headers: this.headers,
+			body: JSON.stringify({ sessionId: this._sessionId }),
+			keepalive: true
+		}).catch(() => {});
+		return true;
+	}
 	async close() {
 		if (this.closed) return;
 		this.closed = true;
@@ -13860,7 +14568,7 @@ var InspectorClient = class InspectorClient extends InspectorClientEventTarget {
 				params: request.params,
 				signal: controller.signal
 			});
-			this.outputValidator ??= new AjvJsonSchemaValidator();
+			this.outputValidator ??= new LinearPatternJsonSchemaValidator();
 			const invalid = validateAppElicitResult(this.outputValidator, request.params, result);
 			if (invalid) {
 				this.logger.warn({
@@ -14459,7 +15167,7 @@ var InspectorClient = class InspectorClient extends InspectorClientEventTarget {
 		});
 	}
 	validateToolOutput(tool, result) {
-		this.outputValidator ??= new AjvJsonSchemaValidator();
+		this.outputValidator ??= new LinearPatternJsonSchemaValidator();
 		return validateToolOutput(this.outputValidator, tool, result);
 	}
 	cancelPendingTaskInput(taskId) {
@@ -15306,6 +16014,10 @@ var InspectorClient = class InspectorClient extends InspectorClientEventTarget {
 	getRemoteBackendSessionId() {
 		if (this.baseTransport instanceof RemoteClientTransport) return this.baseTransport.getRemoteBackendSessionId();
 	}
+	releaseRemoteSessionOnPageHide() {
+		if (this.baseTransport instanceof RemoteClientTransport) return this.baseTransport.releaseOnPageHide();
+		return false;
+	}
 	async resumeAfterOAuth(authorizationCode, options) {
 		await this.completeOAuthFlow(authorizationCode, options?.iss, options?.state);
 		const remoteSessionId = options?.remoteSessionId;
@@ -16032,6 +16744,7 @@ function resolveLoadOptions(flags) {
 	};
 }
 const OTHER_ERRORS = "(other)";
+const NO_TOOL_ERROR_TEXT = "(no text content)";
 const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
 const realClock = {
 	now: () => performance.now(),
@@ -16101,10 +16814,45 @@ var ErrorTally = class {
 		return list;
 	}
 };
+function isLoadStop(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const { reason, detail } = value;
+	return (reason === "interrupted" || reason === "connection_lost" || reason === "consecutive_errors") && typeof detail === "string";
+}
+function toolErrorText(content) {
+	const blocks = Array.isArray(content) ? content : [];
+	for (const block of blocks) {
+		if (typeof block !== "object" || block === null) continue;
+		const { type, text } = block;
+		if (type !== "text" || typeof text !== "string") continue;
+		const trimmed = text.trim();
+		if (trimmed === "") continue;
+		return trimmed.length > 200 ? `${trimmed.slice(0, 200)}…` : trimmed;
+	}
+	return NO_TOOL_ERROR_TEXT;
+}
+const LOAD_FLAG_CONFLICT = "load_flag_conflict";
+function loadSummaryWarnings(summary) {
+	const warnings = [];
+	const stop = summary.stoppedEarly;
+	if (stop !== void 0 && stop.reason !== "interrupted") warnings.push(`Warning: the load run stopped early (${stop.reason}): ${stop.detail}.`);
+	const shortfall = loadRateShortfallWarning(summary);
+	if (shortfall !== void 0) warnings.push(shortfall);
+	return warnings;
+}
+function loadRateShortfallWarning(summary) {
+	const { rate, achievedRate, plannedStarts, droppedSlots } = summary;
+	if (rate === void 0 || plannedStarts === void 0 || droppedSlots === void 0 || plannedStarts === 0) return;
+	const started = plannedStarts - droppedSlots;
+	if (started >= plannedStarts * .9) return void 0;
+	return `Warning: --load-rate ${rate}/s was not reached: ${started} of ${plannedStarts} planned calls started (${achievedRate}/s); ${droppedSlots} slots were dropped because every worker was busy. Raise --load-concurrency or lower --load-rate.`;
+}
 async function runLoad(call, options, clock = realClock, signal) {
 	const { concurrency, durationMs, requests, rate } = options;
-	const latencies = [];
+	const okLatencies = [];
+	const errorLatencies = [];
 	const tally = new ErrorTally();
+	const toolTally = new ErrorTally();
 	let ok = 0;
 	let toolErrors = 0;
 	let errors = 0;
@@ -16113,6 +16861,37 @@ async function runLoad(call, options, clock = realClock, signal) {
 	const deadline = durationMs === void 0 ? Infinity : start + durationMs;
 	const interval = rate === void 0 ? 0 : 1e3 / rate;
 	let nextStart = start;
+	const halt = new AbortController();
+	let stoppedEarly;
+	let stoppedAt = 0;
+	const stopRun = (stop) => {
+		if (stoppedEarly) {
+			if (stop.reason === "interrupted") stoppedEarly = stop;
+			return;
+		}
+		stoppedEarly = stop;
+		stoppedAt = clock.now();
+		halt.abort();
+	};
+	const onAbort = () => {
+		const reason = signal?.reason;
+		stopRun(isLoadStop(reason) ? reason : {
+			reason: "interrupted",
+			detail: "the run was interrupted"
+		});
+	};
+	if (signal?.aborted) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
+	let errorStreak = 0;
+	let streakSince = 0;
+	const noteThrown = (now) => {
+		if (errorStreak++ === 0) streakSince = now;
+		const window = now - streakSince;
+		if ((requests === void 0 || started < requests) && now < deadline && nextStart < deadline && (errorStreak >= 50 || errorStreak >= 5 && window >= 1e3)) stopRun({
+			reason: "consecutive_errors",
+			detail: `${errorStreak} calls in a row threw over ${round(window)}ms; the server looks unavailable`
+		});
+	};
 	let turnstile = Promise.resolve();
 	const claimSlot = async () => {
 		const ahead = turnstile;
@@ -16122,7 +16901,7 @@ async function runLoad(call, options, clock = realClock, signal) {
 		try {
 			if (started > 0 && started % 64 === 0) await yieldToEventLoop();
 			for (;;) {
-				if (signal?.aborted) return false;
+				if (halt.signal.aborted) return false;
 				if (requests !== void 0 && started >= requests) return false;
 				const now = clock.now();
 				if (now >= deadline) return false;
@@ -16133,7 +16912,7 @@ async function runLoad(call, options, clock = realClock, signal) {
 					nextStart = now - nextStart < interval ? nextStart + interval : now + interval;
 					return true;
 				}
-				await sleepUnlessAborted(clock, scheduled - now, signal);
+				await sleepUnlessAborted(clock, scheduled - now, halt.signal);
 			}
 		} finally {
 			release();
@@ -16141,26 +16920,57 @@ async function runLoad(call, options, clock = realClock, signal) {
 	};
 	const worker = async (index) => {
 		while (await claimSlot()) {
-			if (signal?.aborted) return;
+			if (halt.signal.aborted) {
+				started--;
+				return;
+			}
 			const t0 = clock.now();
 			try {
-				if (await call(index) === "ok") ok++;
-				else toolErrors++;
+				const outcome = await call(index);
+				const latency = clock.now() - t0;
+				errorStreak = 0;
+				if (outcome === "ok") {
+					ok++;
+					okLatencies.push(latency);
+				} else {
+					toolErrors++;
+					errorLatencies.push(latency);
+					toolTally.add(typeof outcome === "object" ? outcome.message : NO_TOOL_ERROR_TEXT);
+				}
 			} catch (err) {
+				const now = clock.now();
 				errors++;
+				errorLatencies.push(now - t0);
 				tally.add(err instanceof Error ? err.message : String(err));
+				noteThrown(now);
 			}
-			latencies.push(clock.now() - t0);
 		}
 	};
-	await Promise.all(Array.from({ length: concurrency }, (_, i) => worker(i)));
-	const elapsedMs = clock.now() - start;
+	try {
+		await Promise.all(Array.from({ length: concurrency }, (_, i) => worker(i)));
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+	}
+	const end = clock.now();
+	const requestCapped = requests !== void 0 && started >= requests;
+	const elapsedMs = durationMs !== void 0 && stoppedEarly === void 0 && !requestCapped ? Math.max(end - start, durationMs) : end - start;
 	const completed = ok + toolErrors + errors;
+	const startWindowEnd = () => {
+		let windowEnd = deadline;
+		if (requestCapped) windowEnd = Math.min(windowEnd, nextStart);
+		if (stoppedEarly !== void 0) windowEnd = Math.min(windowEnd, stoppedAt);
+		/* v8 ignore next -- defensive: a run with no duration, no request cap
+		and no stop never ends, so one of the three always applies. */
+		return Number.isFinite(windowEnd) ? windowEnd : end;
+	};
 	return {
 		concurrency,
 		...durationMs !== void 0 && { durationMs },
 		...requests !== void 0 && { requestLimit: requests },
-		...rate !== void 0 && { rate },
+		...rate !== void 0 && rateFigures(rate, {
+			started,
+			windowMs: startWindowEnd() - start
+		}),
 		requests: completed,
 		ok,
 		toolErrors,
@@ -16168,8 +16978,23 @@ async function runLoad(call, options, clock = realClock, signal) {
 		errorRate: completed === 0 ? 0 : round((toolErrors + errors) / completed, 4),
 		elapsedMs: round(elapsedMs),
 		throughput: elapsedMs > 0 ? round(completed * 1e3 / elapsedMs) : 0,
-		latencyMs: summarizeLatency(latencies),
-		errorMessages: tally.entries()
+		okThroughput: elapsedMs > 0 ? round(ok * 1e3 / elapsedMs) : 0,
+		latencyMs: summarizeLatency(okLatencies),
+		errorLatencyMs: summarizeLatency(errorLatencies),
+		errorMessages: tally.entries(),
+		toolErrorMessages: toolTally.entries(),
+		...stoppedEarly !== void 0 && { stoppedEarly }
+	};
+}
+function rateFigures(rate, run) {
+	const { started, windowMs } = run;
+	const slots = Math.ceil(windowMs * rate / 1e3 - 1e-9);
+	const plannedStarts = Math.max(started, slots);
+	return {
+		rate,
+		plannedStarts,
+		droppedSlots: plannedStarts - started,
+		achievedRate: windowMs > 0 ? round(started * 1e3 / windowMs) : 0
 	};
 }
 async function runLoadAcrossConnections(primary, openConnection, callOn, options, clock = realClock, signal) {
@@ -16231,7 +17056,11 @@ async function runToolLoad(inspectorClient, args, options, extra = {}) {
 		/* v8 ignore next 3 -- defensive: `ToolCallInvocation.result` is nullable,
 		but both call paths throw on failure rather than return a null result. */
 		if (invocation.result === null) throw new Error(invocation.error ?? "Tool call failed");
-		return invocation.result.isError === true ? "tool_error" : "ok";
+		if (invocation.result.isError !== true) return "ok";
+		return {
+			outcome: "tool_error",
+			message: toolErrorText(invocation.result.content)
+		};
 	};
 	const summary = await runLoadAcrossConnections(inspectorClient, extra.openConnection, call, options, extra.clock, extra.signal);
 	return {
@@ -16239,6 +17068,41 @@ async function runToolLoad(inspectorClient, args, options, extra = {}) {
 		...summary
 	};
 }
+async function withLoadInterrupt(run, options = {}) {
+	const controller = new AbortController();
+	const exit = options.exit ?? ((code) => process.exit(code));
+	const now = options.now ?? (() => performance.now());
+	let first;
+	const onSignal = (signal) => {
+		if (first !== void 0) {
+			if (signal === first.signal && now() - first.at < 500) return;
+			exit(EXIT_CODES.INTERRUPTED);
+			return;
+		}
+		first = {
+			signal,
+			at: now()
+		};
+		const stop = {
+			reason: "interrupted",
+			detail: `received ${signal}`
+		};
+		controller.abort(stop);
+		if (!options.quiet) process.stderr.write(`Interrupted (${signal}): no further calls will start; waiting for in-flight calls to finish. Press Ctrl+C again to exit now.\n`);
+	};
+	process.on("SIGINT", onSignal);
+	process.on("SIGTERM", onSignal);
+	try {
+		return await run(controller.signal);
+	} finally {
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+	}
+}
+function assertNotInterrupted(summary) {
+	if (summary.stoppedEarly?.reason !== "interrupted") return;
+	throw new CliExitCodeError(EXIT_CODES.INTERRUPTED, `Load run interrupted (${summary.stoppedEarly.detail}); the summary covers the ${summary.requests} calls that completed.`, { code: "interrupted" });
+}
 //#endregion
 //#region ../../core/cli/handlers/load-thresholds.ts
 const LOAD_ERROR_RATE_EXCEEDED = "load_error_rate_exceeded";
@@ -16274,7 +17138,7 @@ function p99Breach(summary, max) {
 	const p99 = summary.latencyMs?.p99;
 	if (p99 === void 0) return {
 		code: LOAD_P99_EXCEEDED,
-		message: `no call completed, so there is no p99 latency to check against --load-max-p99 ${max}`
+		message: `no call succeeded, so there is no p99 latency to check against --load-max-p99 ${max}`
 	};
 	if (p99 <= max) return void 0;
 	return {
@@ -16843,21 +17707,38 @@ async function runMethod(inspectorClient, args, options = {}) {
 //#region ../../core/auth/node/oauth-callback-server.ts
 const DEFAULT_HOSTNAME = "127.0.0.1";
 const DEFAULT_CALLBACK_PATH = "/oauth/callback";
-const SUCCESS_HTML = `<!DOCTYPE html>
-<html>
-<head><meta charset="utf-8"><title>OAuth complete</title></head>
-<body><p>OAuth complete. You can close this window.</p></body>
-</html>`;
-function errorHtml(message) {
+const SUCCESS_HTML = page("OAuth complete", "OAuth complete. You can close this window.");
+const NOT_CALLBACK_HTML = page("Not the OAuth callback", "This address is not the OAuth callback the Inspector is waiting for. Sign-in has not finished; return to the Inspector to continue.");
+const STATE_MISMATCH_HTML = page("OAuth callback ignored", "This callback does not belong to the sign-in in progress and was ignored. Sign-in has not finished; the Inspector is still waiting for the authorization server.");
+const ALREADY_HANDLED_HTML = page("OAuth callback already received", "This sign-in has already received its callback. You can close this window.");
+const STOPPED_HTML = page("OAuth callback not expected", "The Inspector is no longer waiting for this sign-in. Start sign-in again from the Inspector.");
+function errorHtml(serverText) {
+	return page("OAuth error", `OAuth failed. The authorization server said: ${serverText}`);
+}
+function exchangeErrorHtml(message) {
+	return page("OAuth error", `OAuth failed: ${message}`);
+}
+function page(title, text) {
 	return `<!DOCTYPE html>
 <html>
-<head><meta charset="utf-8"><title>OAuth error</title></head>
-<body><p>OAuth failed: ${escapeHtml(message)}</p></body>
+<head><meta charset="utf-8"><title>${escapeHtml(title)}</title></head>
+<body><p>${escapeHtml(text)}</p></body>
 </html>`;
 }
 function escapeHtml(s) {
 	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
+const ANY_STATE = Symbol("any-state");
+const STOPPED = Symbol("stopped");
+function createStopSignal() {
+	let fire;
+	return {
+		stopped: new Promise((resolve) => {
+			fire = () => resolve(STOPPED);
+		}),
+		fire
+	};
+}
 var OAuthCallbackServer = class {
 	server = null;
 	port = 0;
@@ -16865,6 +17746,8 @@ var OAuthCallbackServer = class {
 	handled = false;
 	onCallback;
 	onError;
+	expectedState = Promise.resolve(ANY_STATE);
+	stopSignal = createStopSignal();
 	async start(options = {}) {
 		const { port = 0, hostname = DEFAULT_HOSTNAME, path = DEFAULT_CALLBACK_PATH, onCallback, onError } = options;
 		if (!path.startsWith("/")) return Promise.reject(/* @__PURE__ */ new Error("Callback path must start with '/' (absolute path)"));
@@ -16872,6 +17755,8 @@ var OAuthCallbackServer = class {
 		this.onError = onError;
 		this.handled = false;
 		this.callbackPath = path;
+		this.stopSignal = createStopSignal();
+		this.expectedState = "expectedState" in options ? Promise.race([Promise.resolve(options.expectedState).catch(() => STOPPED), this.stopSignal.stopped]) : Promise.resolve(ANY_STATE);
 		return new Promise((resolve, reject) => {
 			this.server = createServer((req, res) => this.handleRequest(req, res));
 			this.server.on("error", reject);
@@ -16895,6 +17780,7 @@ var OAuthCallbackServer = class {
 	}
 	async stop() {
 		if (!this.server) return;
+		this.stopSignal.fire();
 		await new Promise((resolve) => {
 			this.server.close(() => resolve());
 		});
@@ -16903,11 +17789,14 @@ var OAuthCallbackServer = class {
 	handleRequest(req, res) {
 		const needJson = req.headers["accept"]?.includes("application/json");
 		const send = (status, body, contentType = "text/html; charset=utf-8") => {
-			res.writeHead(status, { "Content-Type": contentType });
+			res.writeHead(status, {
+				"Content-Type": contentType,
+				Connection: "close"
+			});
 			res.end(body);
 		};
 		if (req.method !== "GET") {
-			send(405, needJson ? "{\"error\":\"Method Not Allowed\"}" : SUCCESS_HTML);
+			send(405, needJson ? "{\"error\":\"Method Not Allowed\"}" : NOT_CALLBACK_HTML);
 			return;
 		}
 		let pathname;
@@ -16924,15 +17813,26 @@ var OAuthCallbackServer = class {
 			search = u.search;
 			state = u.searchParams.get("state") ?? void 0;
 		} catch {
-			send(400, needJson ? "{\"error\":\"Bad Request\"}" : SUCCESS_HTML);
+			send(400, needJson ? "{\"error\":\"Bad Request\"}" : NOT_CALLBACK_HTML);
 			return;
 		}
 		if (pathname !== this.callbackPath) {
-			send(404, needJson ? "{\"error\":\"Not Found\"}" : SUCCESS_HTML);
+			send(404, needJson ? "{\"error\":\"Not Found\"}" : NOT_CALLBACK_HTML);
+			return;
+		}
+		this.expectedState.then((expected) => this.handleCallback(expected, state, search, needJson, send));
+	}
+	handleCallback(expected, state, search, needJson, send) {
+		if (expected === STOPPED) {
+			send(503, needJson ? "{\"error\":\"Not waiting for a callback\"}" : STOPPED_HTML);
+			return;
+		}
+		if (expected !== ANY_STATE && state !== expected) {
+			send(400, needJson ? "{\"error\":\"State mismatch\"}" : STATE_MISMATCH_HTML);
 			return;
 		}
 		if (this.handled) {
-			send(409, needJson ? "{\"error\":\"Callback already handled\"}" : SUCCESS_HTML);
+			send(409, needJson ? "{\"error\":\"Callback already handled\"}" : ALREADY_HANDLED_HTML);
 			return;
 		}
 		const params = parseOAuthCallbackParams(search);
@@ -16950,9 +17850,10 @@ var OAuthCallbackServer = class {
 				const msg = err instanceof Error ? err.message : String(err);
 				this.onError?.({
 					error: "callback_error",
-					error_description: msg
+					error_description: msg,
+					source: "callback"
 				});
-				send(500, errorHtml(msg));
+				send(500, exchangeErrorHtml(msg));
 				this.stop();
 			});
 			else {
@@ -16965,7 +17866,8 @@ var OAuthCallbackServer = class {
 		const msg = generateOAuthErrorDescription(params);
 		this.onError?.({
 			error: params.error,
-			error_description: params.error_description ?? void 0
+			error_description: params.error_description ?? void 0,
+			source: "redirect"
 		});
 		send(400, errorHtml(msg));
 	}
@@ -17029,6 +17931,14 @@ function toRunnerOAuthError(err) {
 	}
 	return err instanceof Error ? err : new Error(String(err));
 }
+function stateOf(authorizationUrl) {
+	return authorizationUrl.searchParams.get("state") ?? void 0;
+}
+function callbackErrorMessage(params) {
+	if (params.source === "callback") return params.error_description ?? "OAuth callback failed";
+	if (!params.error && !params.error_description) return "OAuth error";
+	return `OAuth authorization failed. The authorization server said: ${params.error_description ? `${params.error_description} (${params.error})` : params.error}`;
+}
 async function runRunnerInteractiveOAuth(options) {
 	const server = (options.createCallbackServer ?? createOAuthCallbackServer)();
 	let flowResolve;
@@ -17058,11 +17968,16 @@ async function runRunnerInteractiveOAuth(options) {
 		process.on("SIGTERM", onSignal);
 	}
 	let timeoutId;
+	let resolveExpectedState;
+	const expectedState = new Promise((resolve) => {
+		resolveExpectedState = resolve;
+	});
 	try {
 		const { redirectUrl } = await racingSignals(server.start({
 			hostname: options.callbackListen.hostname,
 			port: options.callbackListen.port,
 			path: options.callbackListen.pathname,
+			expectedState,
 			onCallback: async (params) => {
 				try {
 					await options.client.completeOAuthFlow(params.code, params.iss, params.state);
@@ -17072,10 +17987,7 @@ async function runRunnerInteractiveOAuth(options) {
 				}
 			},
 			onError: (params) => {
-				flowReject(new Error(
-					/* v8 ignore next -- params.error is a required non-null string, so the "OAuth error" fallback is unreachable */
-					params.error_description ?? params.error ?? "OAuth error"
-				));
+				flowReject(new Error(callbackErrorMessage(params)));
 			}
 		}));
 		options.onCallbackServer?.(server);
@@ -17091,10 +18003,16 @@ async function runRunnerInteractiveOAuth(options) {
 		})]);
 		waitForCallback.catch(() => {});
 		if (options.authorizationUrl) {
+			resolveExpectedState(stateOf(options.authorizationUrl));
 			await racingSignals(options.client.beginInteractiveAuthorization(options.authorizationUrl));
 			await waitForCallback;
-		} else if (await racingSignals(options.client.authenticate()) !== void 0) await waitForCallback;
-		else return { kind: "already_authorized" };
+		} else {
+			const authUrl = await racingSignals(options.client.authenticate());
+			if (authUrl !== void 0) {
+				resolveExpectedState(stateOf(authUrl));
+				await waitForCallback;
+			} else return { kind: "already_authorized" };
+		}
 		if (options.authChallenge) {
 			if (!await racingSignals(options.client.checkAuthChallengeSatisfied(options.authChallenge, { scopeOnly: true }))) return {
 				kind: "insufficient_scope",
@@ -17460,7 +18378,7 @@ function readInspectorVersion(callerUrl) {
 const validLogLevels = Object.values(LoggingLevelSchema.enum);
 const CLI_CLIENT_NAME = "inspector-cli";
 async function callMethod(serverConfig, serverSettings, args, clientConfig, cliAuthOverrides, callbackUrlConfig, storedAuthOnly, relogin, revoke, load, loadThresholds) {
-	if (load?.connections !== void 0 && load.connections > 1 && !isOAuthCapableServerConfig(serverConfig)) throw new CliExitCodeError(EXIT_CODES.USAGE, "--load-connections above 1 requires an HTTP or SSE server; over stdio each connection would spawn its own server process.");
+	if (load?.connections !== void 0 && load.connections > 1 && !isOAuthCapableServerConfig(serverConfig)) throw new CliExitCodeError(EXIT_CODES.USAGE, "--load-connections above 1 requires an HTTP or SSE server; over stdio each connection would spawn its own server process.", { code: LOAD_FLAG_CONFLICT });
 	if (relogin) {
 		if (!("url" in serverConfig && serverConfig.url)) throw new Error("--relogin requires an HTTP/SSE server URL (no OAuth store entry for stdio)");
 		const revocation = await clearStoredAuthForRelogin(serverConfig.url, { revoke: revoke && serverSettings?.oauthRevokeOnClear !== false });
@@ -17527,12 +18445,17 @@ async function callMethod(serverConfig, serverSettings, args, clientConfig, cliA
 			quiet: args.quiet
 		});
 		if (load) {
-			const summary = await withCliAuthRecoveryRetry(inspectorClient, serverConfig, redirectUrlProvider, callbackUrlConfig, serverSettings, () => runToolLoad(inspectorClient, args, load, { openConnection: openLoadConnection }), {
+			const summary = await withLoadInterrupt((signal) => withCliAuthRecoveryRetry(inspectorClient, serverConfig, redirectUrlProvider, callbackUrlConfig, serverSettings, () => runToolLoad(inspectorClient, args, load, {
+				openConnection: openLoadConnection,
+				signal
+			}), {
 				storedAuthOnly,
 				autoOpenControl,
 				quiet: args.quiet
-			});
+			}), { quiet: args.quiet });
 			await writeFormattedResult(summary, args.format === "json" ? "json" : "text");
+			if (!args.quiet) for (const warning of loadSummaryWarnings(summary)) await awaitableError(`${warning}\n`);
+			assertNotInterrupted(summary);
 			checkLoadThresholds(summary, loadThresholds);
 			return;
 		}
@@ -17798,7 +18721,7 @@ async function parseArgs(argv) {
 		];
 		if (!validTransports.includes(value)) throw new Error(`Invalid transport type: ${value}. Valid types are: ${validTransports.join(", ")}`);
 		return value;
-	}).option("--server-url <url>", "Server URL for SSE/HTTP transport").option("--header <headers...>", "HTTP headers as \"HeaderName: Value\" pairs (for HTTP/SSE transports)", parseHeaderPair, {}).option("--metadata <pairs...>", "General metadata as key=value pairs (applied to all methods)", parseKeyValuePair, {}).option("--tool-metadata <pairs...>", "Tool-specific metadata as key=value pairs (for tools/call method only)", parseKeyValuePair, {}).option("--app-info", "Probe the tool's MCP App UI metadata (resourceUri, csp, permissions, domain) and emit it as one JSON line; exit 2 when the tool has no app. Use with --method tools/call --tool-name <name> (the tool itself is not invoked) or --method tools/list (one NDJSON line per tool).").option("--advertise-apps", "Advertise the MCP Apps UI extension (io.modelcontextprotocol/ui) at initialize. Off by default because the CLI cannot render an App; set it when a server only exposes its App tools to a client that claims App support, e.g. for an --app-info probe.").option("--strict", "Report tool-schema portability problems in full (path, issue, suggested fix) on stderr, and exit 6 if any is error-severity. Use with --method tools/list. Without it, a one-line count is printed instead.").option("--verify", "Run the SEP-2640 conformance and digest checks over the skills returned, emit one JSON report per skill on stdout, and exit 7 if any fails or 8 if any could not be fully checked within the read bounds. Use with --method skills/list or --method skills/get.").option("--require-digests", "With --verify: exit 9 when a skill advertises no digests (resources: \"dynamic\"), instead of reporting it as unverifiable and exiting 0.").option("--load", "Load-test one tool: call it repeatedly and concurrently, then print a latency and error-rate summary instead of a result. Use with --method tools/call --tool-name <name>. Bounded by --load-duration (default 10s) and/or --load-requests.").option("--load-concurrency <n>", "With --load: most calls in flight at once (positive integer; default 10).", positiveIntegerParser("--load-concurrency")).option("--load-connections <n>", "With --load: spread the calls over this many independent connections (sessions) to an HTTP or SSE server, opened before timing starts (positive integer, at most --load-concurrency; default 1).", positiveIntegerParser("--load-connections")).option("--load-duration <sec>", "With --load: stop starting calls after this many seconds; in-flight calls still finish (default 10 when --load-requests is not set).", positiveNumberParser("--load-duration")).option("--load-requests <n>", "With --load: stop after starting this many calls (positive integer).", positiveIntegerParser("--load-requests")).option("--load-rate <n>", "With --load: start at most this many calls per second, spread evenly (positive number; default unlimited).", positiveNumberParser("--load-rate")).option("--load-max-error-rate <fraction>", "With --load: exit 10 (load_error_rate_exceeded) when the share of failed calls is above this value, after printing the summary (0 to 1; 0 fails on any failed call).", fractionParser("--load-max-error-rate")).option("--load-max-p99 <ms>", "With --load: exit 10 (load_p99_exceeded) when the p99 latency is above this many milliseconds, or when no call completed, after printing the summary (positive number).", maxP99Parser).option("--connect-timeout <ms>", `Connection timeout in ms (default ${DEFAULT_CONNECT_TIMEOUT_MS} for ad-hoc --server-url / target invocations; 0 = no timeout).`, (v) => {
+	}).option("--server-url <url>", "Server URL for SSE/HTTP transport").option("--header <headers...>", "HTTP headers as \"HeaderName: Value\" pairs (for HTTP/SSE transports)", parseHeaderPair, {}).option("--metadata <pairs...>", "General metadata as key=value pairs (applied to all methods)", parseKeyValuePair, {}).option("--tool-metadata <pairs...>", "Tool-specific metadata as key=value pairs (for tools/call method only)", parseKeyValuePair, {}).option("--app-info", "Probe the tool's MCP App UI metadata (resourceUri, csp, permissions, domain) and emit it as one JSON line; exit 2 when the tool has no app. Use with --method tools/call --tool-name <name> (the tool itself is not invoked) or --method tools/list (one NDJSON line per tool).").option("--advertise-apps", "Advertise the MCP Apps UI extension (io.modelcontextprotocol/ui) at initialize. Off by default because the CLI cannot render an App; set it when a server only exposes its App tools to a client that claims App support, e.g. for an --app-info probe.").option("--strict", "Report tool-schema portability problems in full (path, issue, suggested fix) on stderr, and exit 6 if any is error-severity. Use with --method tools/list. Without it, a one-line count is printed instead.").option("--verify", "Run the SEP-2640 conformance and digest checks over the skills returned, emit one JSON report per skill on stdout, and exit 7 if any fails or 8 if any could not be fully checked within the read bounds. Use with --method skills/list or --method skills/get.").option("--require-digests", "With --verify: exit 9 when a skill advertises no digests (resources: \"dynamic\"), instead of reporting it as unverifiable and exiting 0.").option("--load", "Load-test one tool: call it repeatedly and concurrently, then print a latency and error-rate summary instead of a result. Use with --method tools/call --tool-name <name>. Bounded by --load-duration (default 10s) and/or --load-requests.").option("--load-concurrency <n>", "With --load: most calls in flight at once (positive integer; default 10).", positiveIntegerParser("--load-concurrency")).option("--load-connections <n>", "With --load: spread the calls over this many independent connections (sessions) to an HTTP or SSE server, opened before timing starts (positive integer, at most --load-concurrency; default 1).", positiveIntegerParser("--load-connections")).option("--load-duration <sec>", "With --load: stop starting calls after this many seconds; in-flight calls still finish (default 10 when --load-requests is not set).", positiveNumberParser("--load-duration")).option("--load-requests <n>", "With --load: stop after starting this many calls (positive integer).", positiveIntegerParser("--load-requests")).option("--load-rate <n>", "With --load: start at most this many calls per second, spread evenly (positive number; default unlimited).", positiveNumberParser("--load-rate")).option("--load-max-error-rate <fraction>", "With --load: exit 10 (load_error_rate_exceeded) when the share of failed calls is above this value, after printing the summary (0 to 1; 0 fails on any failed call).", fractionParser("--load-max-error-rate")).option("--load-max-p99 <ms>", "With --load: exit 10 (load_p99_exceeded) when the p99 latency of the successful calls is above this many milliseconds, or when no call succeeded, after printing the summary (positive number).", maxP99Parser).option("--connect-timeout <ms>", `Connection timeout in ms (default ${DEFAULT_CONNECT_TIMEOUT_MS} for ad-hoc --server-url / target invocations; 0 = no timeout).`, (v) => {
 		const n = Number(v);
 		if (!Number.isFinite(n) || n < 0) throw new Error(`--connect-timeout must be a non-negative number.`);
 		return n;
@@ -17849,12 +18772,12 @@ async function parseArgs(argv) {
 		["--load-max-error-rate", options.loadMaxErrorRate],
 		["--load-max-p99", options.loadMaxP99]
 	];
-	for (const [flag, value] of loadBounds) if (value !== void 0 && !options.load) throw new Error(`${flag} requires --load.`);
+	for (const [flag, value] of loadBounds) if (value !== void 0 && !options.load) throw loadFlagConflict(`${flag} requires --load.`);
 	if (options.load) {
-		if (options.method !== "tools/call") throw new Error("--load requires --method tools/call.");
-		if (options.appInfo) throw new Error("--load cannot be combined with --app-info.");
-		if (options.listStoredAuth || options.printHandoff) throw new Error("--load cannot be combined with --list-stored-auth or --print-handoff.");
-		if (options.output !== void 0 || options.outputFormat !== void 0) throw new Error("--load cannot be combined with --output or --output-format; redirect stdout to keep the summary.");
+		if (options.method !== "tools/call") throw loadFlagConflict("--load requires --method tools/call.");
+		if (options.appInfo) throw loadFlagConflict("--load cannot be combined with --app-info.");
+		if (options.listStoredAuth || options.printHandoff) throw loadFlagConflict("--load cannot be combined with --list-stored-auth or --print-handoff.");
+		if (options.output !== void 0 || options.outputFormat !== void 0) throw loadFlagConflict("--load cannot be combined with --output or --output-format; redirect stdout to keep the summary.");
 	}
 	if (options.advertiseApps && (options.listStoredAuth || options.printHandoff || options.method === "servers/list" || options.method === "servers/show" || isCatalogWriteMethod(options.method))) throw new Error("--advertise-apps requires a command that connects to a server; it has no effect with --list-stored-auth, --print-handoff, or a --method servers/* catalog command.");
 	const oauthStatePath = getStateFilePath();
@@ -18002,14 +18925,24 @@ async function parseArgs(argv) {
 		storedAuthOnly: options.storedAuthOnly === true,
 		relogin: options.relogin === true,
 		revoke: options.revoke !== false,
-		...options.load && { load: resolveLoadOptions({
+		...options.load && { load: resolveCliLoadOptions(options) }
+	};
+}
+function loadFlagConflict(message) {
+	return new CliExitCodeError(EXIT_CODES.USAGE, message, { code: LOAD_FLAG_CONFLICT });
+}
+function resolveCliLoadOptions(options) {
+	try {
+		return resolveLoadOptions({
 			concurrency: options.loadConcurrency,
 			connections: options.loadConnections,
 			durationSec: options.loadDuration,
 			requests: options.loadRequests,
 			rate: options.loadRate
-		}) }
-	};
+		});
+	} catch (err) {
+		throw loadFlagConflict(err.message);
+	}
 }
 function discardWarning() {}
 async function runCli(argv) {