@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/mcp-handler.js

@@ -1,7 +1,46 @@
+import { build, fixed, jsonText, msg, plainText, quote } from "./message-text.js";
+import { decodeMcpHeaderValue, resolveMcpIdentity } from "./helpers.js";
 import { createJsonRpcDispatcher } from "./jsonrpc.js";
+import { MCP_FAKE_ERROR_CODES } from "./types.js";
 import { randomUUID } from "node:crypto";
 
 //#region src/mcp-handler.ts
+/**
+* `data.aimock.code` of a `tools/call` whose fake claim threw: an aimock
+* defect (a validated entry whose result could not be built or sent), not a
+* scenario failure. Answered with the JSON-RPC internal-error code `-32603`;
+* the entry stays unconsumed.
+*/
+const MCP_FAKE_INTERNAL_ERROR = "MCP_FAKE_INTERNAL_ERROR";
+const MCP_FAKE_INTERNAL_ERROR_RPC_CODE = -32603;
+/** An empty record, for the caller to pass in and read even if the handler throws. */
+function newMCPRequestRecord() {
+	return {
+		identity: null,
+		messages: []
+	};
+}
+/**
+* C8: the `onToolCall` handlers that answer a config `mcp.tools[].result`.
+* `tools/call` reports such an answer as `answeredBy: "config"`. Internal:
+* not exported from the package.
+*/
+const configToolHandlers = /* @__PURE__ */ new WeakSet();
+/** C7: the syslog levels of `logging/setLevel`, lowest first. */
+const LOG_LEVELS = [
+	"debug",
+	"info",
+	"notice",
+	"warning",
+	"error",
+	"critical",
+	"alert",
+	"emergency"
+];
+/** C7: the rank of a syslog level name, or -1 when it is not one. */
+function logLevelRank(level) {
+	return typeof level === "string" ? LOG_LEVELS.indexOf(level) : -1;
+}
 function jsonRpcResult(id, result) {
 	return {
 		jsonrpc: "2.0",
@@ -9,26 +48,195 @@ function jsonRpcResult(id, result) {
 		result
 	};
 }
-function jsonRpcError(id, code, message) {
+function jsonRpcError(id, code, message, data) {
 	return {
 		jsonrpc: "2.0",
 		id,
-		error: {
+		error: data === void 0 ? {
 			code,
 			message
+		} : {
+			code,
+			message,
+			data
 		}
 	};
 }
+/**
+* The identity part of a fake message or log line (I9): `testId "<id>"`,
+* `context "<ctx>"`, both, or `no testId or context`.
+*/
+function describeMcpIdentity(identity) {
+	const { testId, context } = identity;
+	if (testId !== null && context !== null) return msg`testId ${quote(testId)}, context ${quote(context)}`;
+	if (testId !== null) return msg`testId ${quote(testId)}`;
+	if (context !== null) return msg`context ${quote(context)}`;
+	return msg`no testId or context`;
+}
+/** A value as JSON text for a message part. */
+function jsonPart(value) {
+	return jsonText(JSON.stringify(value) ?? "null");
+}
+/**
+* The 9.2 error for a failed claim (`mismatch`, `exhausted`, `evicted`), or
+* for an undeclared tool under `deny` (`not_declared`).
+*/
+function fakeFailure(claim, tool, ctx, declaredTools) {
+	const who = describeMcpIdentity(ctx.identity);
+	const base = {
+		tool,
+		testId: ctx.identity.testId,
+		context: ctx.identity.context,
+		mount: ctx.mount
+	};
+	switch (claim.kind) {
+		case "mismatch": {
+			const list = claim.declared.map((d) => d.args !== void 0 ? msg`${plainText(d.id)} ${jsonPart(d.args)}` : msg`${plainText(d.id)} anyArgs`).reduce((acc, part, i) => i === 0 ? part : msg`${acc}; ${part}`, msg`none`);
+			return {
+				code: "MCP_FAKE_MISMATCH",
+				outcome: "mismatch",
+				message: build(msg`aimock MCP fake mismatch: tool ${quote(tool)} was called with arguments that match no declared fake (${who}). Received ${jsonPart(claim.received)}. Declared: ${list}.`),
+				aimock: {
+					code: "MCP_FAKE_MISMATCH",
+					...base,
+					received: claim.received,
+					declared: claim.declared,
+					firstDifference: claim.firstDifference
+				}
+			};
+		}
+		case "exhausted": {
+			const used = claim.matchingDeclared === 1 ? msg`the 1 matching fake is` : msg`all ${claim.matchingDeclared} matching fakes are`;
+			return {
+				code: "MCP_FAKE_EXHAUSTED",
+				outcome: "exhausted",
+				message: build(msg`aimock MCP fake exhausted: tool ${quote(tool)} with ${jsonPart(claim.received)} was called again, but ${used} already used (${who}).`),
+				aimock: {
+					code: "MCP_FAKE_EXHAUSTED",
+					...base,
+					received: claim.received,
+					matchingDeclared: claim.matchingDeclared,
+					matchingConsumed: claim.matchingConsumed,
+					matchingIds: claim.matchingIds
+				}
+			};
+		}
+		case "evicted": return {
+			code: "MCP_FAKE_EVICTED",
+			outcome: "evicted",
+			evicted: {
+				testId: claim.testId,
+				cap: claim.maxTestIds
+			},
+			message: build(msg`aimock MCP fake evicted: consumption state for testId ${quote(claim.testId)} was evicted by the per-mount test-id cap (${claim.maxTestIds}); reset before reusing this test id (${who}).`),
+			aimock: {
+				code: "MCP_FAKE_EVICTED",
+				...base,
+				testId: claim.testId,
+				cap: claim.maxTestIds
+			}
+		};
+		case "not_declared": return {
+			code: "MCP_FAKE_NOT_DECLARED",
+			outcome: "not_declared",
+			message: build(msg`Unknown tool: ${plainText(tool)} (aimock MCP fake not declared: this scenario denies undeclared tools; ${who}).`),
+			aimock: {
+				code: "MCP_FAKE_NOT_DECLARED",
+				...base,
+				declaredTools: declaredTools()
+			}
+		};
+	}
+}
 function createMCPRequestHandler(state) {
+	/** Per-request fake context, set by the outer handler for the dispatcher's methods. */
+	const contexts = /* @__PURE__ */ new WeakMap();
+	/** C7: each session's `logging/setLevel` level; dropped on DELETE. */
+	const logLevels = /* @__PURE__ */ new Map();
+	/** The initialize capabilities: `logging` only on a mount with recorded logs (C7). */
+	const capabilities = () => state.fakes.hasRecordedLogs() ? {
+		tools: {},
+		resources: {},
+		prompts: {},
+		logging: {}
+	} : {
+		tools: {},
+		resources: {},
+		prompts: {}
+	};
+	/**
+	* Spec 10 steps 1-2 for `tools/call`: a fake answer or fake failure, or
+	* `null` to fall through to today's behavior (step 3).
+	*/
+	const callFake = (ctx, outcome, tool, args, id) => {
+		const event = {
+			identity: ctx.identity,
+			tool,
+			mount: ctx.mount,
+			args
+		};
+		let claim;
+		try {
+			claim = state.fakes.claim(tool, args, ctx.identity);
+		} catch (err) {
+			const thrown = err instanceof Error ? err.message : String(err);
+			const message = build(msg`aimock MCP fake internal error: tool ${quote(tool)} could not be answered (${describeMcpIdentity(ctx.identity)}): ${plainText(thrown)}`);
+			outcome.error = message;
+			state.onFakeEvent({
+				...event,
+				kind: "internal_error",
+				code: MCP_FAKE_INTERNAL_ERROR,
+				message
+			});
+			return jsonRpcError(id, MCP_FAKE_INTERNAL_ERROR_RPC_CODE, message, { aimock: {
+				code: MCP_FAKE_INTERNAL_ERROR,
+				tool,
+				testId: ctx.identity.testId,
+				context: ctx.identity.context,
+				mount: ctx.mount,
+				error: thrown
+			} });
+		}
+		if (claim.kind === "answer") {
+			outcome.mcpFake = {
+				id: claim.entry.id,
+				outcome: "answered"
+			};
+			state.onFakeEvent({
+				...event,
+				kind: "answered",
+				entryId: claim.entry.id
+			});
+			return jsonRpcResult(id, claim.result);
+		}
+		let failure;
+		if (claim.kind === "none") {
+			if (state.fakes.policy(ctx.identity) !== "deny") return null;
+			failure = fakeFailure({ kind: "not_declared" }, tool, ctx, () => state.fakes.declaredTools(ctx.identity));
+		} else failure = fakeFailure(claim, tool, ctx, () => []);
+		outcome.mcpFake = {
+			id: null,
+			outcome: failure.outcome
+		};
+		state.onFakeEvent(failure.outcome === "evicted" ? {
+			...event,
+			kind: "evicted",
+			code: failure.code,
+			message: failure.message,
+			...failure.evicted
+		} : {
+			...event,
+			kind: failure.outcome,
+			code: failure.code,
+			message: failure.message
+		});
+		return jsonRpcError(id, MCP_FAKE_ERROR_CODES[failure.code], failure.message, { aimock: failure.aimock });
+	};
 	const dispatcher = createJsonRpcDispatcher({ methods: {
 		initialize: async (_params, id) => {
 			return jsonRpcResult(id, {
 				protocolVersion: "2025-03-26",
-				capabilities: {
-					tools: {},
-					resources: {},
-					prompts: {}
-				},
+				capabilities: capabilities(),
 				serverInfo: state.serverInfo
 			});
 		},
@@ -41,15 +249,68 @@ function createMCPRequestHandler(state) {
 		ping: async (_params, id) => {
 			return jsonRpcResult(id, {});
 		},
-		"tools/list": async (_params, id) => {
+		"logging/setLevel": async (params, id, req) => {
+			if (!state.fakes.hasRecordedLogs()) return jsonRpcError(id, -32601, "Method not found");
+			const level = params ?? {};
+			if (logLevelRank(level.level) === -1) return jsonRpcError(id, -32602, "Invalid log level");
+			const sessionId = req.headers["mcp-session-id"];
+			if (typeof sessionId === "string") logLevels.set(sessionId, String(level.level));
+			return jsonRpcResult(id, {});
+		},
+		"tools/list": async (_params, id, req) => {
 			const tools = [];
 			for (const { def } of state.tools.values()) tools.push(def);
+			const ctx = contexts.get(req);
+			const recorded = ctx ? state.fakes.recordedList(ctx.identity) : null;
+			if (ctx && recorded) {
+				const listed = [...recorded];
+				const names = new Set(recorded.map((t) => t.name));
+				for (const def of tools) if (!names.has(def.name)) {
+					names.add(def.name);
+					listed.push(def);
+				}
+				for (const fake of state.fakes.listTools(ctx.identity)) if (!names.has(fake.name)) {
+					names.add(fake.name);
+					listed.push(fake);
+				}
+				return jsonRpcResult(id, { tools: listed });
+			}
+			if (ctx) {
+				const registered = new Set(tools.map((t) => t.name));
+				for (const fake of state.fakes.listTools(ctx.identity)) if (!registered.has(fake.name)) tools.push(fake);
+			}
 			return jsonRpcResult(id, { tools });
 		},
-		"tools/call": async (params, id) => {
-			const { name, arguments: args } = params ?? {};
-			if (!name) return jsonRpcError(id, -32602, "Missing tool name");
+		"tools/call": async (params, id, req) => {
+			const ctx = contexts.get(req);
+			const precomputed = ctx?.precomputed;
+			if (ctx) ctx.precomputed = void 0;
+			const isNotification = !precomputed && ctx?.notifications[ctx.calls.length] === true;
+			if (!precomputed) ctx?.calls.push({
+				mcpFake: null,
+				error: null
+			});
+			const outcome = ctx?.calls[ctx.calls.length - 1] ?? {
+				mcpFake: null,
+				error: null
+			};
+			const { name: rawName, arguments: args } = params ?? {};
+			if (!rawName) return jsonRpcError(id, -32602, "Missing tool name");
+			if (typeof rawName !== "string") return jsonRpcError(id, -32602, build(msg`Invalid tool name: expected a string, got ${fixed(Array.isArray(rawName) ? "array" : typeof rawName)}`));
+			const name = rawName;
+			if (precomputed?.kind === "reply") return precomputed.value;
+			if (ctx && !isNotification && !precomputed) {
+				const fake = callFake(ctx, outcome, name, args, id);
+				if (fake) return fake;
+			}
 			const entry = state.tools.get(name);
+			if (ctx && !isNotification) state.onUnfaked({
+				identity: ctx.identity,
+				tool: name,
+				mount: ctx.mount,
+				args,
+				answeredBy: !entry ? "unknown-tool" : entry.handler && configToolHandlers.has(entry.handler) ? "config" : entry.handler ? "handler" : "empty"
+			});
 			if (!entry) return jsonRpcError(id, -32602, `Unknown tool: ${name}`);
 			if (entry.handler) try {
 				const result = await entry.handler(args);
@@ -109,50 +370,126 @@ function createMCPRequestHandler(state) {
 			return jsonRpcResult(id, { messages: [] });
 		}
 	} });
-	return async (req, res, body) => {
+	/** Answer a rejected identity (H4, H5) with HTTP 400, in the session-error shape. */
+	const rejectIdentity = (res, resolution) => {
+		res.writeHead(resolution.error.status, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			error: resolution.error.message,
+			code: resolution.error.code
+		}));
+	};
+	/**
+	* L2: report each identity value that fell back to the raw value (H1),
+	* naming its source (header or query) and the value itself, and any query
+	* name that did not decode. `fellBack` says only that some value of the
+	* field fell back; the header is checked on its own, and the query by the
+	* same resolver given the query alone, so the rules are the resolver's.
+	*/
+	const reportFallback = (sessionId, req, resolution) => {
+		if (!state.hasFakes()) return;
+		const { fellBack } = resolution;
+		if (fellBack.testId || fellBack.context) {
+			const queryOnly = resolveMcpIdentity({
+				headers: {},
+				url: req.url
+			});
+			for (const field of ["testId", "context"]) {
+				if (!fellBack[field]) continue;
+				const header = req.headers[IDENTITY_HEADERS[field]];
+				const headerSent = typeof header === "string" && header !== "";
+				if (headerSent && decodeMcpHeaderValue(header).fellBack) state.onDecodeFallback(sessionId, {
+					kind: "value",
+					field,
+					source: "header",
+					raw: header,
+					used: true
+				});
+				const fromQuery = queryOnly.ok && queryOnly.fellBack[field] ? queryOnly.identity[field] : null;
+				if (fromQuery !== null) state.onDecodeFallback(sessionId, {
+					kind: "value",
+					field,
+					source: "query",
+					raw: fromQuery,
+					used: !headerSent
+				});
+			}
+		}
+		if (resolution.undecodedQueryNames) state.onDecodeFallback(sessionId, {
+			kind: "names",
+			count: resolution.undecodedQueryNames
+		});
+	};
+	/**
+	* Handle one MCP request. `mount` is the path the mount is served at (I9;
+	* `/` for a standalone server). Resolves with what the request resolved,
+	* for the mount's journal entry.
+	*/
+	return async (req, res, body, mount = "/", record = newMCPRequestRecord()) => {
+		/** T1: recorded `atMs` / `durationMs` are measured from here. */
+		const arrivedAt = performance.now();
 		if (req.method === "DELETE") {
 			const sessionId = req.headers["mcp-session-id"];
 			if (!sessionId) {
 				res.writeHead(400, { "Content-Type": "application/json" });
 				res.end(JSON.stringify({ error: "Missing mcp-session-id header" }));
-				return;
+				return record;
 			}
 			if (!state.sessions.has(sessionId)) {
 				res.writeHead(404, { "Content-Type": "application/json" });
 				res.end(JSON.stringify({ error: "Session not found" }));
-				return;
+				return record;
 			}
+			const resolution = resolveMcpIdentity(req, state.sessions.get(sessionId));
+			if (resolution.ok) record.identity = resolution.identity;
 			state.sessions.delete(sessionId);
+			logLevels.delete(sessionId);
+			state.onSessionClosed(sessionId);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ ok: true }));
-			return;
+			return record;
 		}
+		const headerSessionId = req.headers["mcp-session-id"];
+		const knownSession = headerSessionId ? state.sessions.get(headerSessionId) : void 0;
 		let parsed;
 		try {
 			parsed = JSON.parse(body);
 		} catch {
+			const resolution = resolveMcpIdentity(req, knownSession);
+			if (!resolution.ok) {
+				rejectIdentity(res, resolution);
+				return record;
+			}
+			record.identity = resolution.identity;
+			if (headerSessionId && knownSession) reportFallback(headerSessionId, req, resolution);
 			await dispatcher(req, res, body);
-			return;
+			return record;
 		}
 		const method = typeof parsed === "object" && parsed !== null && "method" in parsed ? parsed.method : void 0;
 		if (method === "initialize") {
 			const id = typeof parsed === "object" && parsed !== null && "id" in parsed ? parsed.id : null;
+			const resolution = resolveMcpIdentity(req);
+			if (!resolution.ok) {
+				rejectIdentity(res, resolution);
+				return record;
+			}
+			record.identity = resolution.identity;
+			const { identity, supplied } = resolution;
 			const sessionId = randomUUID();
 			state.sessions.set(sessionId, {
 				id: sessionId,
 				initialized: false,
-				createdAt: Date.now()
+				createdAt: Date.now(),
+				...supplied.testId && identity.testId !== null ? { testId: identity.testId } : {},
+				...supplied.context && identity.context !== null ? { context: identity.context } : {},
+				...supplied.undeclared && identity.undeclared !== null ? { undeclared: identity.undeclared } : {}
 			});
+			reportFallback(sessionId, req, resolution);
 			const response = {
 				jsonrpc: "2.0",
 				id,
 				result: {
 					protocolVersion: "2025-03-26",
-					capabilities: {
-						tools: {},
-						resources: {},
-						prompts: {}
-					},
+					capabilities: capabilities(),
 					serverInfo: state.serverInfo
 				}
 			};
@@ -161,28 +498,193 @@ function createMCPRequestHandler(state) {
 				"Mcp-Session-Id": sessionId
 			});
 			res.end(JSON.stringify(response));
-			return;
+			return record;
+		}
+		const resolution = resolveMcpIdentity(req, knownSession);
+		if (!resolution.ok) {
+			rejectIdentity(res, resolution);
+			return record;
 		}
-		const sessionId = req.headers["mcp-session-id"];
+		record.identity = resolution.identity;
+		const sessionId = headerSessionId;
 		if (!sessionId) {
 			res.writeHead(400, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ error: "Missing mcp-session-id header" }));
-			return;
+			return record;
 		}
 		if (!state.sessions.has(sessionId)) {
 			res.writeHead(404, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ error: "Session not found" }));
-			return;
+			return record;
 		}
+		reportFallback(sessionId, req, resolution);
 		if (!state.sessions.get(sessionId).initialized && method !== "notifications/initialized") {
 			res.writeHead(400, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(jsonRpcError(typeof parsed === "object" && parsed !== null && "id" in parsed ? parsed.id : null, -32002, "Session not initialized")));
-			return;
+			return record;
+		}
+		const notifications = (Array.isArray(parsed) ? parsed : [parsed]).filter((m) => isToolsCall(m) && m.jsonrpc === "2.0").map((m) => !("id" in m));
+		const ctx = {
+			identity: resolution.identity,
+			mount,
+			notifications,
+			calls: []
+		};
+		contexts.set(req, ctx);
+		const single = singleToolsCall(parsed);
+		if (single) {
+			const outcome = {
+				mcpFake: null,
+				error: null
+			};
+			ctx.calls.push(outcome);
+			const fake = callFake(ctx, outcome, single.name, single.args, single.id);
+			const replay = fake && outcome.mcpFake?.outcome === "answered" && outcome.mcpFake.id !== null ? state.fakes.replayOf(outcome.mcpFake.id) : null;
+			if (fake && "result" in fake && replay && (replay.notifications.length > 0 || replay.timing === "recorded" && replay.durationMs !== void 0)) {
+				await writeFakeToolAnswer(req, res, single.id, fake.result, replay, single.params, state.replaySpeed(), logLevels.get(sessionId) ?? null, arrivedAt);
+				record.messages = [{
+					body: single.message,
+					mcpFake: outcome.mcpFake,
+					error: outcome.error
+				}];
+				return record;
+			}
+			ctx.precomputed = fake ? {
+				kind: "reply",
+				value: fake
+			} : { kind: "none" };
 		}
 		await dispatcher(req, res, body);
+		let next = 0;
+		const messageOf = (message) => {
+			if (!isToolsCall(message)) return {
+				body: null,
+				mcpFake: null,
+				error: null
+			};
+			const outcome = message.jsonrpc === "2.0" ? ctx.calls[next++] : void 0;
+			return {
+				body: message,
+				mcpFake: outcome?.mcpFake ?? null,
+				error: outcome?.error ?? null
+			};
+		};
+		record.messages = Array.isArray(parsed) ? parsed.map(messageOf) : [messageOf(parsed)];
+		return record;
+	};
+}
+/**
+* A single JSON-RPC `tools/call` request (not a batch, not a notification)
+* with a string or number id and a string tool name, else `null`. Only such
+* a message is claimed by the outer handler (MR15).
+*/
+function singleToolsCall(parsed) {
+	if (!isToolsCall(parsed) || parsed.jsonrpc !== "2.0" || !("id" in parsed)) return null;
+	const id = parsed.id;
+	if (typeof id !== "string" && typeof id !== "number") return null;
+	const params = parsed.params;
+	if (typeof params !== "object" || params === null) return null;
+	const name = params.name;
+	if (typeof name !== "string" || name === "") return null;
+	return {
+		message: parsed,
+		id,
+		name,
+		args: params.arguments,
+		params
+	};
+}
+/** Resolve after `ms` (no wait when `ms <= 0`). */
+function sleep(ms) {
+	return ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+}
+/** The client's `_meta.progressToken` of a request's params, else `undefined`. */
+function progressTokenOf(params) {
+	if (typeof params !== "object" || params === null) return void 0;
+	const meta = params._meta;
+	if (typeof meta !== "object" || meta === null) return void 0;
+	const token = meta.progressToken;
+	return typeof token === "string" || typeof token === "number" ? token : void 0;
+}
+/**
+* FA3 gate of one recorded notification for this request: the params to send,
+* or `null` when it does not replay. `notifications/progress` replays only
+* when the request carries a progress token, which replaces the recorded one;
+* `notifications/message` only when the session set a log level (C7) and the
+* line is at or above it. No other method replays.
+*/
+function replayedParams(notification, progressToken, logLevel) {
+	if (notification.method === "notifications/progress") return progressToken === void 0 ? null : {
+		...notification.params,
+		progressToken
 	};
+	if (notification.method === "notifications/message") {
+		const min = logLevelRank(logLevel);
+		const rank = logLevelRank(notification.params.level);
+		return min !== -1 && rank >= min ? { ...notification.params } : null;
+	}
+	return null;
+}
+/**
+* Write a fake's tools/call answer. SSE iff the entry has a notification whose
+* FA3 gate passes AND Accept lists text/event-stream; else JSON. Timing per T1
+* (value / speed) unless the block's timing is "immediate". `logLevel` is the
+* session's `logging/setLevel` level (C7), `arrivedAt` the `performance.now()`
+* of the request's arrival, which `atMs` and `durationMs` are measured from.
+*/
+async function writeFakeToolAnswer(req, res, id, result, replay, params, speed, logLevel = null, arrivedAt = performance.now()) {
+	const timed = replay !== null && replay.timing === "recorded";
+	const waitUntil = (atMs) => timed ? sleep(atMs / speed - (performance.now() - arrivedAt)) : Promise.resolve();
+	const token = progressTokenOf(params);
+	const notifications = [...replay?.notifications ?? []].sort((a, b) => a.atMs - b.atMs).flatMap((n) => {
+		const sent = replayedParams(n, token, logLevel);
+		return sent ? [{
+			atMs: n.atMs,
+			method: n.method,
+			params: sent
+		}] : [];
+	});
+	const accept = req.headers.accept ?? "";
+	const answer = {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+	if (notifications.length > 0 && accept.includes("text/event-stream")) {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache"
+		});
+		res.flushHeaders();
+		for (const n of notifications) {
+			await waitUntil(n.atMs);
+			if (res.destroyed) return;
+			res.write(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				method: n.method,
+				params: n.params
+			})}\n\n`);
+		}
+		if (replay?.durationMs !== void 0) await waitUntil(replay.durationMs);
+		if (res.destroyed) return;
+		res.end(`event: message\ndata: ${JSON.stringify(answer)}\n\n`);
+		return;
+	}
+	if (replay?.durationMs !== void 0) await waitUntil(replay.durationMs);
+	if (res.destroyed) return;
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(answer));
+}
+/** The identity header of each field whose value can fall back (H1). */
+const IDENTITY_HEADERS = {
+	testId: "x-test-id",
+	context: "x-aimock-context"
+};
+/** A JSON-RPC message object whose method is `tools/call`. */
+function isToolsCall(message) {
+	return typeof message === "object" && message !== null && !Array.isArray(message) && "method" in message && message.method === "tools/call";
 }
 
 //#endregion
-export { createMCPRequestHandler };
+export { configToolHandlers, createMCPRequestHandler, describeMcpIdentity, fakeFailure, newMCPRequestRecord, writeFakeToolAnswer };
 //# sourceMappingURL=mcp-handler.js.map