@warlock.js/ai-tools 5.32.0 → 5.34.0

package/cjs/index.cjs

@@ -1294,6 +1294,28 @@ function mcp$1(server, options) {
 	return new McpClientImpl(server, options);
 }
 
+//#endregion
+//#region ../../packages/ai-tools/src/mcp/error.ts
+/** An application-defined JSON-RPC error thrown by MCP serving policy hooks. */
+var McpError = class extends Error {
+	constructor(code, message, data) {
+		super(message);
+		this.name = "McpError";
+		this.code = code;
+		this.data = data;
+	}
+};
+/**
+* Recognize our error and the SDK's McpError without a runtime SDK dependency.
+* SDK source (checked 2026-10-19):
+* https://github.com/modelcontextprotocol/typescript-sdk/blob/v1.x/src/types.ts
+* Only explicitly named errors with an integer code opt in; ordinary throws
+* retain the existing mapping. Preserve the error's message verbatim.
+*/
+function isMcpError(cause) {
+	return cause instanceof Error && cause.name === "McpError" && "code" in cause && typeof cause.code === "number" && Number.isInteger(cause.code);
+}
+
 //#endregion
 //#region ../../packages/ai-tools/src/mcp/protocol.ts
 /**
@@ -1315,6 +1337,147 @@ const SUPPORTED_PROTOCOL_VERSIONS = [
 /** The newest MCP protocol version the server speaks. */
 const LATEST_PROTOCOL_VERSION = "2025-11-25";
 
+//#endregion
+//#region ../../packages/ai-tools/src/mcp/result.ts
+const NATIVE_RESULT = Symbol("mcpResult");
+/**
+* Opt in to native MCP content, error status, structured output and metadata.
+* Validation happens after invoke(), so malformed payloads become JSON-RPC
+* errors rather than being caught as tool execution errors.
+*/
+function mcpResult(result) {
+	return { [NATIVE_RESULT]: result };
+}
+/** Read a branded value without accepting lookalike application objects. */
+function isMcpResult(value) {
+	return isRecord(value) && NATIVE_RESULT in value;
+}
+/** Get the original payload; no cloning, normalization or field stripping. */
+function unwrapMcpResult(value) {
+	return value[NATIVE_RESULT];
+}
+/** Objects with result fields are candidates only when native mode is enabled. */
+function looksLikeMcpResult(value) {
+	return isRecord(value) && [
+		"content",
+		"isError",
+		"structuredContent",
+		"_meta"
+	].some((key) => key in value);
+}
+/** Non-array object used by the MCP JSON object fields. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+	return value === void 0 || typeof value === "string";
+}
+function validAnnotations(value) {
+	if (value === void 0) return true;
+	if (!isRecord(value)) return false;
+	return (value.audience === void 0 || Array.isArray(value.audience) && value.audience.every((role) => role === "user" || role === "assistant")) && (value.priority === void 0 || typeof value.priority === "number" && value.priority >= 0 && value.priority <= 1) && optionalString(value.lastModified);
+}
+function validMetadata(value) {
+	return (value["_meta"] === void 0 || isRecord(value["_meta"])) && validAnnotations(value.annotations);
+}
+function validIcon(value) {
+	return isRecord(value) && typeof value.src === "string" && optionalString(value.mimeType) && (value.sizes === void 0 || Array.isArray(value.sizes) && value.sizes.every((size) => typeof size === "string")) && (value.theme === void 0 || value.theme === "light" || value.theme === "dark");
+}
+function validContent(value) {
+	if (!isRecord(value) || !validMetadata(value)) return false;
+	switch (value.type) {
+		case "text": return typeof value.text === "string";
+		case "image":
+		case "audio": return typeof value.data === "string" && typeof value.mimeType === "string";
+		case "resource_link": return typeof value.uri === "string" && typeof value.name === "string" && optionalString(value.title) && optionalString(value.description) && optionalString(value.mimeType) && (value.size === void 0 || typeof value.size === "number") && (value.icons === void 0 || Array.isArray(value.icons) && value.icons.every(validIcon));
+		case "resource": {
+			const resource = value.resource;
+			return isRecord(resource) && typeof resource.uri === "string" && optionalString(resource.mimeType) && validMetadata(resource) && (typeof resource.text === "string" || typeof resource.blob === "string");
+		}
+		default: return false;
+	}
+}
+/** Reject values JSON would drop, coerce or fail to encode (including cycles). */
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return false;
+	ancestors.add(value);
+	const valid = Array.isArray(value) ? Array.from(value).every((entry) => isJsonValue(entry, ancestors)) : Object.values(value).every((entry) => entry === void 0 || isJsonValue(entry, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+/**
+* MCP 2025-11-25 CallToolResult and ContentBlock fields:
+* https://modelcontextprotocol.io/specification/2025-11-25/server/tools#tool-result
+* https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/schema/2025-11-25/schema.ts
+* structuredContent is preserved even when tools/list declares outputSchema.
+* Tool authors remain responsible for conformity to that application schema.
+*/
+function assertMcpResult(value) {
+	if (!isRecord(value) || !Array.isArray(value.content) || !Array.from(value.content).every(validContent) || value.isError !== void 0 && typeof value.isError !== "boolean" || value.structuredContent !== void 0 && !isRecord(value.structuredContent) || value["_meta"] !== void 0 && !isRecord(value["_meta"]) || !isJsonValue(value)) throw new TypeError("Invalid native MCP CallToolResult.");
+}
+
+//#endregion
+//#region ../../packages/ai-tools/src/mcp/serve-requests.ts
+/**
+* In-flight requests for one transport. HTTP partitions these by credentials;
+* stdio has a single connection. Cancellation never crosses those boundaries.
+* https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/cancellation
+* (checked 2026-10-19): ignore unknown/completed ids and never answer cancelled work.
+*/
+var McpServeRequests = class {
+	constructor() {
+		this.scopes = /* @__PURE__ */ new Map();
+	}
+	cancel(message, scope = "") {
+		if (!isRecord(message) || message.jsonrpc !== "2.0" || message.method !== "notifications/cancelled" || message.id !== void 0 || !isRecord(message.params)) return;
+		const { requestId, reason } = message.params;
+		if (typeof requestId !== "string" && typeof requestId !== "number" || reason !== void 0 && typeof reason !== "string") return;
+		const pending = this.scopes.get(scope)?.get(requestId);
+		if (pending?.size === 1) {
+			for (const entry of pending) if (entry.cancellable) entry.controller.abort(new DOMException(typeof reason === "string" ? reason : "Request cancelled.", "AbortError"));
+		}
+	}
+	async run(request, context, dispatch, scope = "") {
+		let pending = this.scopes.get(scope);
+		if (!pending) {
+			pending = /* @__PURE__ */ new Map();
+			this.scopes.set(scope, pending);
+		}
+		const controller = new AbortController();
+		const entry = {
+			controller,
+			cancellable: request.method !== "initialize"
+		};
+		const calls = pending.get(request.id) ?? /* @__PURE__ */ new Set();
+		calls.add(entry);
+		pending.set(request.id, calls);
+		const onAbort = () => controller.abort(context.signal?.reason);
+		context.signal?.addEventListener("abort", onAbort, { once: true });
+		if (context.signal?.aborted) onAbort();
+		try {
+			if (controller.signal.aborted) return;
+			const response = await dispatch({
+				...context,
+				requestId: request.id,
+				signal: controller.signal
+			});
+			return controller.signal.aborted ? void 0 : response;
+		} catch (cause) {
+			if (controller.signal.aborted) return;
+			throw cause;
+		} finally {
+			context.signal?.removeEventListener("abort", onAbort);
+			calls.delete(entry);
+			if (calls.size === 0) pending.delete(request.id);
+			if (pending.size === 0) this.scopes.delete(scope);
+		}
+	}
+};
+
 //#endregion
 //#region ../../packages/ai-tools/src/mcp/serve-http.ts
 /**
@@ -1324,7 +1487,7 @@ const LATEST_PROTOCOL_VERSION = "2025-11-25";
 * specification (https://modelcontextprotocol.io/specification/2025-11-25/basic/transports,
 * checked 2026-10-17) on `node:http`, with no SDK dependency:
 *
-* - one endpoint path; each POST carries exactly one JSON-RPC message
+* - one MCP endpoint path (plus optional authenticated app routes); each MCP POST carries exactly one JSON-RPC message
 *   (batches were removed from the protocol in 2025-06-18 and get 400);
 * - a request is answered with `Content-Type: application/json` (the spec
 *   lets a server pick JSON or SSE per request); a notification or a
@@ -1382,6 +1545,35 @@ function hostnameOf(hostHeader) {
 function digest(value) {
 	return (0, node_crypto.createHash)("sha256").update(value, "utf8").digest();
 }
+/** Resolve exact descendant routes; no route may replace the MCP endpoint. */
+function resolveRoutes(path, routes) {
+	const resolved = /* @__PURE__ */ new Map();
+	const methods = /* @__PURE__ */ new Set([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"HEAD",
+		"OPTIONS"
+	]);
+	if (routes.length > 0) {
+		let canonical = false;
+		try {
+			canonical = !path.startsWith("//") && new URL(path, "http://localhost").pathname === path;
+		} catch {}
+		if (!canonical) throw new McpServeError("MCP http routes require a canonical endpoint pathname.", { type: "config" });
+	}
+	for (const route of routes) {
+		if (!methods.has(route.method) || !/^\/[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)*$/.test(route.path) || route.path.split("/").some((segment) => segment === "." || segment === "..") || typeof route.handler !== "function") throw new McpServeError("Invalid MCP http route method, path or handler.", { type: "config" });
+		const fullPath = `${path.replace(/\/+$/, "")}${route.path}`;
+		const byMethod = resolved.get(fullPath) ?? /* @__PURE__ */ new Map();
+		if (fullPath === path || byMethod.has(route.method)) throw new McpServeError(`MCP http route "${route.method} ${fullPath}" conflicts.`, { type: "collision" });
+		byMethod.set(route.method, { ...route });
+		resolved.set(fullPath, byMethod);
+	}
+	return resolved;
+}
 /** Normalise a configured origin to `scheme://host[:port]`, or throw a config error. */
 function normalizeOrigin(origin) {
 	try {
@@ -1413,9 +1605,9 @@ function resolveSettings(transport) {
 	const tokens = auth?.bearer === void 0 ? [] : typeof auth.bearer === "string" ? [auth.bearer] : [...auth.bearer];
 	if (tokens.some((token) => token.length === 0)) throw new McpServeError("MCP http auth.bearer tokens must be non-empty strings.", { type: "config" });
 	if (auth && auth.bearer !== void 0 && tokens.length === 0) throw new McpServeError("MCP http auth.bearer needs at least one token.", { type: "config" });
-	if (auth && tokens.length === 0 && !auth.authorize) throw new McpServeError("MCP http auth needs `bearer` and/or `authorize`.", { type: "config" });
-	const authRequired = tokens.length > 0 || auth?.authorize !== void 0;
-	if (!loopback && !authRequired) throw new McpServeError(`Refusing to serve MCP over http on non-loopback host "${host}" without auth. Set transport.auth ({ bearer } or { authorize }), or bind 127.0.0.1.`, {
+	if (auth && tokens.length === 0 && !auth.authorize && !auth.authenticate) throw new McpServeError("MCP http auth needs `bearer`, `authorize` and/or `authenticate`.", { type: "config" });
+	const authRequired = tokens.length > 0 || auth?.authorize !== void 0 || auth?.authenticate !== void 0;
+	if (!loopback && !authRequired) throw new McpServeError(`Refusing to serve MCP over http on non-loopback host "${host}" without auth. Set transport.auth ({ bearer }, { authorize } or { authenticate }), or bind 127.0.0.1.`, {
 		type: "config",
 		context: { host }
 	});
@@ -1428,9 +1620,11 @@ function resolveSettings(transport) {
 		drainTimeoutMs,
 		tokenDigests: tokens.map(digest),
 		authorize: auth?.authorize,
+		authenticate: auth?.authenticate,
 		authRequired,
 		allowedOrigins: new Set((transport.allowedOrigins ?? []).map(normalizeOrigin)),
-		allowedHosts: new Set((transport.allowedHosts ?? []).map((name) => hostnameOf(name)))
+		allowedHosts: new Set((transport.allowedHosts ?? []).map((name) => hostnameOf(name))),
+		routes: resolveRoutes(path, transport.routes ?? [])
 	};
 }
 /** Flatten Node's header bag into lower-cased `name → value` strings. */
@@ -1486,6 +1680,7 @@ function sendEmpty(response, status, headers = {}) {
 async function startHttpServer(transport, dispatch) {
 	const settings = resolveSettings(transport);
 	const shutdown = new AbortController();
+	const requests = new McpServeRequests();
 	const inFlight = /* @__PURE__ */ new Set();
 	let closing;
 	const server = (0, node_http.createServer)((request, response) => {
@@ -1493,7 +1688,7 @@ async function startHttpServer(transport, dispatch) {
 			sendRefusal(response, 503, JSON_RPC_SERVER_ERROR, "Server is shutting down.", { connection: "close" });
 			return;
 		}
-		const work = handleRequest(request, response, settings, dispatch, shutdown.signal).catch(() => {
+		const work = handleRequest(request, response, settings, dispatch, shutdown.signal, requests).catch(() => {
 			sendRefusal(response, 500, JSON_RPC_SERVER_ERROR, "Internal server error.");
 		});
 		inFlight.add(work);
@@ -1552,13 +1747,15 @@ async function startHttpServer(transport, dispatch) {
 	};
 }
 /**
-* Validate and answer one HTTP request: path → Host / Origin → auth →
-* method → headers → body → JSON-RPC dispatch.
+* Validate and answer one HTTP request: Host / Origin → path → auth →
+* method → route handler or MCP headers/body/JSON-RPC dispatch.
 */
-async function handleRequest(request, response, settings, dispatch, signal) {
+async function handleRequest(request, response, settings, dispatch, signal, requests) {
 	const headers = flattenHeaders(request.headers);
 	const method = (request.method ?? "GET").toUpperCase();
-	const path = new URL(request.url ?? "/", "http://localhost").pathname;
+	const url = new URL(request.url ?? "/", "http://localhost");
+	const path = url.pathname;
+	const routes = settings.routes.get(path);
 	if (!hostAllowed(headers.host, settings)) {
 		sendRefusal(response, 403, JSON_RPC_SERVER_ERROR, "Forbidden: Host header not allowed.");
 		return;
@@ -1567,7 +1764,7 @@ async function handleRequest(request, response, settings, dispatch, signal) {
 		sendRefusal(response, 403, JSON_RPC_SERVER_ERROR, "Forbidden: Origin not allowed.");
 		return;
 	}
-	if (path !== settings.path) {
+	if (path !== settings.path && !routes) {
 		sendRefusal(response, 404, JSON_RPC_SERVER_ERROR, "Not found.");
 		return;
 	}
@@ -1577,11 +1774,21 @@ async function handleRequest(request, response, settings, dispatch, signal) {
 		headers
 	};
 	if (request.socket.remoteAddress !== void 0) info.remoteAddress = request.socket.remoteAddress;
-	if (!await authorized(info, settings)) {
-		const challenge = settings.tokenDigests.length > 0 ? { "www-authenticate": "Bearer realm=\"mcp\"" } : {};
+	const authentication = await authorized(info, settings);
+	if (!authentication.allowed) {
+		const challenge = settings.tokenDigests.length > 0 || settings.authenticate ? { "www-authenticate": "Bearer realm=\"mcp\"" } : {};
 		sendRefusal(response, 401, JSON_RPC_SERVER_ERROR, "Unauthorized.", challenge);
 		return;
 	}
+	if (routes) {
+		const route = routes.get(method);
+		if (!route) {
+			sendEmpty(response, 405, { allow: [...routes.keys()].sort().join(", ") });
+			return;
+		}
+		await handleRoute(request, response, route, info, url, authentication.principal, signal, settings);
+		return;
+	}
 	if (method !== "POST") {
 		sendEmpty(response, 405, { allow: "POST" });
 		return;
@@ -1623,6 +1830,7 @@ async function handleRequest(request, response, settings, dispatch, signal) {
 	const id = record.id;
 	if (typeof record.method === "string") {
 		if (typeof id !== "string" && typeof id !== "number") {
+			requests.cancel(record, cancellationScope(info));
 			sendEmpty(response, 202);
 			return;
 		}
@@ -1632,10 +1840,20 @@ async function handleRequest(request, response, settings, dispatch, signal) {
 			method: record.method
 		};
 		if (record.params !== void 0) rpcRequest.params = record.params;
-		sendJson(response, 200, await dispatch(rpcRequest, {
-			request: info,
-			signal
-		}));
+		const disconnected = new AbortController();
+		const onClose = () => disconnected.abort();
+		response.once("close", onClose);
+		try {
+			const rpcResponse = await requests.run(rpcRequest, {
+				request: info,
+				principal: authentication.principal,
+				signal: AbortSignal.any([signal, disconnected.signal])
+			}, (context) => dispatch(rpcRequest, context), cancellationScope(info));
+			if (rpcResponse === void 0) sendEmpty(response, 202);
+			else sendJson(response, 200, rpcResponse);
+		} finally {
+			response.off("close", onClose);
+		}
 		return;
 	}
 	if ((typeof id === "string" || typeof id === "number") && ("result" in record || "error" in record)) {
@@ -1644,6 +1862,32 @@ async function handleRequest(request, response, settings, dispatch, signal) {
 	}
 	sendRefusal(response, 400, JSON_RPC_INVALID_REQUEST$1, "Invalid request: not a JSON-RPC message.");
 }
+/** Run a side route after the shared guards, tracking disconnect and shutdown. */
+async function handleRoute(request, response, route, info, url, principal, shutdown, settings) {
+	const disconnected = new AbortController();
+	const onClose = () => disconnected.abort();
+	response.once("close", onClose);
+	try {
+		const body = await readBody$1(request, settings.maxBodyBytes);
+		if (body.type === "too-large") {
+			sendRefusal(response, 413, JSON_RPC_SERVER_ERROR, `Request body exceeds ${settings.maxBodyBytes} bytes.`, { connection: "close" });
+			return;
+		}
+		const signal = AbortSignal.any([shutdown, disconnected.signal]);
+		signal.throwIfAborted();
+		const result = await route.handler({
+			request: info,
+			url,
+			principal,
+			body: body.text,
+			signal
+		});
+		if (result.body === void 0 || info.method === "HEAD") sendEmpty(response, result.status ?? 200, result.headers);
+		else sendJson(response, result.status ?? 200, result.body, result.headers);
+	} finally {
+		response.off("close", onClose);
+	}
+}
 /**
 * Host-header check. While bound to loopback only loopback names (plus
 * `allowedHosts`) are accepted, so a DNS-rebound name pointing at
@@ -1674,27 +1918,50 @@ function originAllowed(origin, settings) {
 	if (settings.allowedOrigins.has(parsed.origin)) return true;
 	return (parsed.protocol === "http:" || parsed.protocol === "https:") && isLoopbackHost(parsed.hostname);
 }
-/**
-* Run the configured auth. Bearer tokens are compared in constant time
-* over SHA-256 digests (equal-length buffers for `timingSafeEqual`), and
-* every configured token is compared so the match position does not leak.
-* An `authorize` hook that throws denies the request.
-*/
 async function authorized(info, settings) {
-	if (!settings.authRequired) return true;
+	if (!settings.authRequired) return { allowed: true };
 	if (settings.tokenDigests.length > 0) {
 		const match = /^Bearer[ \t]+(.+)$/i.exec(info.headers.authorization ?? "");
 		const presented = digest(match?.[1]?.trim() ?? "");
 		let matched = false;
 		for (const expected of settings.tokenDigests) matched = (0, node_crypto.timingSafeEqual)(presented, expected) || matched;
-		if (!match || !matched) return false;
+		if (!match || !matched) return { allowed: false };
 	}
-	if (settings.authorize) try {
-		return await settings.authorize(info) === true;
+	try {
+		if (settings.authorize && await settings.authorize(info) !== true) return { allowed: false };
+		if (settings.authenticate) {
+			const principal = await settings.authenticate(info);
+			return principal === void 0 ? { allowed: false } : {
+				allowed: true,
+				principal
+			};
+		}
+		return { allowed: true };
 	} catch {
-		return false;
-	}
-	return true;
+		return { allowed: false };
+	}
+}
+/**
+* Stateless HTTP has no connection/session id. Repeat the caller's credential
+* and application headers on notifications; per-message transport headers do
+* not identify a caller. Hash the material rather than retaining secrets as keys.
+*/
+function cancellationScope(info) {
+	const transportHeaders = /* @__PURE__ */ new Set([
+		"host",
+		"origin",
+		"accept",
+		"accept-encoding",
+		"accept-language",
+		"connection",
+		"content-type",
+		"content-length",
+		"transfer-encoding",
+		"mcp-protocol-version",
+		"user-agent"
+	]);
+	const credentials = Object.entries(info.headers).filter(([name]) => !transportHeaders.has(name)).sort(([left], [right]) => left.localeCompare(right));
+	return digest(JSON.stringify([info.remoteAddress, credentials])).toString("hex");
 }
 /** True for `application/json` (any parameters, e.g. `; charset=utf-8`). */
 function isJsonContentType(contentType) {
@@ -1751,89 +2018,6 @@ function readBody$1(request, limit) {
 	});
 }
 
-//#endregion
-//#region ../../packages/ai-tools/src/mcp/result.ts
-const NATIVE_RESULT = Symbol("mcpResult");
-/**
-* Opt in to native MCP content, error status, structured output and metadata.
-* Validation happens after invoke(), so malformed payloads become JSON-RPC
-* errors rather than being caught as tool execution errors.
-*/
-function mcpResult(result) {
-	return { [NATIVE_RESULT]: result };
-}
-/** Read a branded value without accepting lookalike application objects. */
-function isMcpResult(value) {
-	return isRecord(value) && NATIVE_RESULT in value;
-}
-/** Get the original payload; no cloning, normalization or field stripping. */
-function unwrapMcpResult(value) {
-	return value[NATIVE_RESULT];
-}
-/** Objects with result fields are candidates only when native mode is enabled. */
-function looksLikeMcpResult(value) {
-	return isRecord(value) && [
-		"content",
-		"isError",
-		"structuredContent",
-		"_meta"
-	].some((key) => key in value);
-}
-/** Non-array object used by the MCP JSON object fields. */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalString(value) {
-	return value === void 0 || typeof value === "string";
-}
-function validAnnotations(value) {
-	if (value === void 0) return true;
-	if (!isRecord(value)) return false;
-	return (value.audience === void 0 || Array.isArray(value.audience) && value.audience.every((role) => role === "user" || role === "assistant")) && (value.priority === void 0 || typeof value.priority === "number" && value.priority >= 0 && value.priority <= 1) && optionalString(value.lastModified);
-}
-function validMetadata(value) {
-	return (value["_meta"] === void 0 || isRecord(value["_meta"])) && validAnnotations(value.annotations);
-}
-function validIcon(value) {
-	return isRecord(value) && typeof value.src === "string" && optionalString(value.mimeType) && (value.sizes === void 0 || Array.isArray(value.sizes) && value.sizes.every((size) => typeof size === "string")) && (value.theme === void 0 || value.theme === "light" || value.theme === "dark");
-}
-function validContent(value) {
-	if (!isRecord(value) || !validMetadata(value)) return false;
-	switch (value.type) {
-		case "text": return typeof value.text === "string";
-		case "image":
-		case "audio": return typeof value.data === "string" && typeof value.mimeType === "string";
-		case "resource_link": return typeof value.uri === "string" && typeof value.name === "string" && optionalString(value.title) && optionalString(value.description) && optionalString(value.mimeType) && (value.size === void 0 || typeof value.size === "number") && (value.icons === void 0 || Array.isArray(value.icons) && value.icons.every(validIcon));
-		case "resource": {
-			const resource = value.resource;
-			return isRecord(resource) && typeof resource.uri === "string" && optionalString(resource.mimeType) && validMetadata(resource) && (typeof resource.text === "string" || typeof resource.blob === "string");
-		}
-		default: return false;
-	}
-}
-/** Reject values JSON would drop, coerce or fail to encode (including cycles). */
-function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (typeof value !== "object" || ancestors.has(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) return false;
-	ancestors.add(value);
-	const valid = Array.isArray(value) ? Array.from(value).every((entry) => isJsonValue(entry, ancestors)) : Object.values(value).every((entry) => entry === void 0 || isJsonValue(entry, ancestors));
-	ancestors.delete(value);
-	return valid;
-}
-/**
-* MCP 2025-11-25 CallToolResult and ContentBlock fields:
-* https://modelcontextprotocol.io/specification/2025-11-25/server/tools#tool-result
-* https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/schema/2025-11-25/schema.ts
-* structuredContent is preserved even when tools/list declares outputSchema.
-* Tool authors remain responsible for conformity to that application schema.
-*/
-function assertMcpResult(value) {
-	if (!isRecord(value) || !Array.isArray(value.content) || !Array.from(value.content).every(validContent) || value.isError !== void 0 && typeof value.isError !== "boolean" || value.structuredContent !== void 0 && !isRecord(value.structuredContent) || value["_meta"] !== void 0 && !isRecord(value["_meta"]) || !isJsonValue(value)) throw new TypeError("Invalid native MCP CallToolResult.");
-}
-
 //#endregion
 //#region ../../packages/ai-tools/src/mcp/serve.ts
 /** JSON-RPC version literal every outbound message carries. */
@@ -1952,7 +2136,10 @@ var McpServeHandler = class {
 	*/
 	async handle(request, context = {}) {
 		try {
-			return this.ok(request.id, await this.dispatch(request, context));
+			return this.ok(request.id, await this.dispatch(request, {
+				...context,
+				requestId: request.id
+			}));
 		} catch (cause) {
 			if (cause instanceof RpcFailure) return this.error(request.id, cause.code, cause.message, cause.data);
 			const message = cause instanceof Error ? cause.message : String(cause);
@@ -1964,8 +2151,14 @@ var McpServeHandler = class {
 		switch (request.method) {
 			case "initialize": return this.initializeResult(request.params);
 			case "ping": return {};
-			case "tools/list": return { tools: this.listTools() };
-			case "tools/call": return this.callTool(request.params, context);
+			case "tools/list": return { tools: await this.listTools({
+				...context,
+				requestId: request.id
+			}) };
+			case "tools/call": return this.callTool(request.params, {
+				...context,
+				requestId: request.id
+			});
 		}
 		if (this.resources) switch (request.method) {
 			case "resources/list": return { resources: this.listResources(this.resources) };
@@ -2004,9 +2197,9 @@ var McpServeHandler = class {
 	* the configured dialect (default `draft-2020-12` — overriding
 	* `extractJsonSchema`'s own `openai-strict` default to a neutral MCP draft).
 	*/
-	listTools() {
+	async listTools(context) {
 		const target = this.options.schemaTarget ?? DEFAULT_SCHEMA_TARGET;
-		return this.tools.map(({ name, contract }) => {
+		const tools = this.tools.map(({ name, contract }) => {
 			const inputSchema = (0, _warlock_js_ai.extractJsonSchema)(contract.input, { target }) ?? {
 				type: "object",
 				properties: {}
@@ -2018,6 +2211,8 @@ var McpServeHandler = class {
 				...isRecord(contract.meta?.outputSchema) ? { outputSchema: contract.meta.outputSchema } : {}
 			};
 		});
+		context.signal?.throwIfAborted();
+		return this.options.listFilter ? this.options.listFilter(context, tools) : tools;
 	}
 	/**
 	* Route a `tools/call` to the named contract's `invoke()` and map the
@@ -2031,12 +2226,25 @@ var McpServeHandler = class {
 	*/
 	async callTool(params, context) {
 		const { name, args } = readCallParams(params);
+		if (this.options.validateCallParams) {
+			context.signal?.throwIfAborted();
+			try {
+				await this.options.validateCallParams(context, readRecord(params));
+			} catch (cause) {
+				if (isMcpError(cause)) throw new RpcFailure(cause.code, cause.message, cause.data);
+				throw cause;
+			}
+		}
 		const contract = this.byName.get(name);
 		if (!contract) throw new McpTransportError(`Unknown tool "${name}".`, {
 			type: "protocol",
 			method: "tools/call"
 		});
-		const toolContext = { artifacts: {} };
+		const toolContext = {
+			artifacts: {},
+			requestId: context.requestId,
+			principal: context.principal
+		};
 		if (context.signal) toolContext.signal = context.signal;
 		if (context.request) {
 			const { headers, remoteAddress } = context.request;
@@ -2045,6 +2253,49 @@ var McpServeHandler = class {
 				remoteAddress
 			};
 		}
+		if (this.options.beforeCall) {
+			let input = args;
+			if (contract.input) {
+				let validation;
+				try {
+					validation = await contract.input["~standard"].validate(args);
+				} catch (cause) {
+					return {
+						content: [{
+							type: "text",
+							text: `Schema validation threw for tool "${name}": ${cause instanceof Error ? cause.message : String(cause)}`
+						}],
+						isError: true
+					};
+				}
+				if (validation.issues) return {
+					content: [{
+						type: "text",
+						text: `Validation failed: ${validation.issues.map((issue) => issue.message).join("; ")}`
+					}],
+					isError: true
+				};
+				input = validation.value;
+			}
+			context.signal?.throwIfAborted();
+			let refusal;
+			try {
+				refusal = await this.options.beforeCall(context, contract, input);
+			} catch (cause) {
+				if (isMcpError(cause)) throw new RpcFailure(cause.code, cause.message, cause.data);
+				throw cause;
+			}
+			if (refusal !== void 0) {
+				try {
+					assertMcpResult(refusal);
+					if (refusal.isError !== true) throw new Error("A refusal must be an error result.");
+				} catch {
+					throw new RpcFailure(JSON_RPC_INTERNAL_ERROR, "Invalid MCP beforeCall refusal.");
+				}
+				return refusal;
+			}
+		}
+		context.signal?.throwIfAborted();
 		const result = await contract.invoke(args, toolContext);
 		if (result.error) return {
 			content: [{
@@ -2175,7 +2426,7 @@ const JSON_RPC_INTERNAL_ERROR = -32603;
 * answered with a JSON-RPC "Invalid Request" error whose `id` is `null`.
 * Never rejects: a dispatch failure is answered as an internal error.
 */
-async function answerStdioLine(line, dispatch) {
+async function answerStdioLine(line, dispatch, notify) {
 	const trimmed = line.trim();
 	if (!trimmed) return;
 	let message;
@@ -2194,10 +2445,21 @@ async function answerStdioLine(line, dispatch) {
 	})}\n`;
 	const request = message;
 	const id = request.id;
-	if (id === void 0 || id === null) return;
+	if (id === void 0 || id === null) {
+		notify?.(message);
+		return;
+	}
+	if (typeof id !== "string" && typeof id !== "number") return `${JSON.stringify({
+		jsonrpc: JSONRPC_VERSION,
+		id: null,
+		error: {
+			code: JSON_RPC_INVALID_REQUEST,
+			message: "Invalid request: id must be a string or number."
+		}
+	})}\n`;
 	try {
 		const response = await dispatch(request);
-		return `${JSON.stringify(response)}\n`;
+		return response === void 0 ? void 0 : `${JSON.stringify(response)}\n`;
 	} catch {
 		return `${JSON.stringify({
 			jsonrpc: JSONRPC_VERSION,
@@ -2281,7 +2543,7 @@ var McpServerImpl = class {
 	start() {
 		if (!this.running) {
 			const transport = this.options.transport ?? { type: "stdio" };
-			const starting = transport.type === "http" ? this.startHttp(transport) : Promise.resolve(this.startStdio());
+			const starting = transport.type === "http" ? this.startHttp(transport) : Promise.resolve(this.startStdio(transport));
 			this.running = starting.catch((error) => {
 				this.running = void 0;
 				throw error;
@@ -2301,19 +2563,29 @@ var McpServerImpl = class {
 		};
 	}
 	/** Wire the stdin line reader and answer each request on stdout. */
-	startStdio() {
+	startStdio(transport) {
+		const shutdown = new AbortController();
+		const requests = new McpServeRequests();
 		const reader = (0, node_readline.createInterface)({ input: process.stdin });
+		reader.once("close", () => shutdown.abort());
 		reader.on("line", (line) => {
-			this.onLine(line).catch(() => {});
+			this.onLine(line, transport, requests, shutdown.signal).catch(() => {});
 		});
 		return { close: async () => {
+			shutdown.abort();
 			reader.close();
 			this.running = void 0;
 		} };
 	}
 	/** Answer one stdin line on stdout (see {@link answerStdioLine}). */
-	async onLine(line) {
-		const reply = await answerStdioLine(line, (request) => this.handler.handle(request));
+	async onLine(line, transport, requests, signal) {
+		const reply = await answerStdioLine(line, (request) => requests.run(request, { signal }, async (context) => {
+			const principal = transport.principalProvider ? await transport.principalProvider(context) : transport.principal;
+			return this.handler.handle(request, {
+				...context,
+				principal
+			});
+		}), (message) => requests.cancel(message));
 		if (reply !== void 0) process.stdout.write(reply);
 	}
 	async stop() {
@@ -3397,20 +3669,20 @@ function webSearchTool(options) {
 
 //#endregion
 //#region ../../packages/ai-tools/src/register.ts
-_warlock_js_ai.ai.tools = {
+Object.assign(_warlock_js_ai.ai.tools, {
 	webSearch: webSearchTool,
 	fetchUrl: fetchUrlTool,
 	http: httpRequestTool,
 	calculator: calculatorTool,
-	dateTime: (options) => dateTimeTool(options),
-	measure: _warlock_js_ai.measureTools
-};
+	dateTime: (options) => dateTimeTool(options)
+});
 _warlock_js_ai.ai.mcp = mcp;
 
 //#endregion
 exports.CalculatorError = CalculatorError;
 exports.DateTimeError = DateTimeError;
 exports.HttpPolicyError = HttpPolicyError;
+exports.McpError = McpError;
 exports.McpServeError = McpServeError;
 exports.McpTransportError = McpTransportError;
 exports.SUPPORTED_PROTOCOL_VERSIONS = SUPPORTED_PROTOCOL_VERSIONS;