@yolk-sdk/emulators 0.1.0-canary.96

package/dist/mcp/api.mjs

@@ -0,0 +1,557 @@
+import { isJsonObject, isNotEmulated, notEmulated, parseJsonText, streamedCommit } from "../stateful-emulator.mjs";
+import { mcpEmulatorFixtures } from "./recordings.mjs";
+import { mcpEmulatorLegacyPath, mcpEmulatorModernPath, mcpEmulatorOrigin, mcpEmulatorSessionPrefix } from "./state.mjs";
+import { Predicate } from "effect";
+//#region src/mcp/api.ts
+/**
+* MCP emulator route table (internal): one wire route per recorded HTTP shape (`POST /modern/mcp`,
+* `POST /legacy/mcp`, `GET /legacy/mcp`), each answering only the JSON-RPC methods its profile's
+* fixtures record, as manifest variants (`RPC <origin><path>#<method>`, plus the `GET` row).
+*
+* A request is admitted only when it equals a recorded request (`src/mcp/recordings.ts`) within
+* the latitude: the MCP headers (`accept`, `content-type`, `mcp-method`, `mcp-protocol-version`,
+* `mcp-name`, `last-event-id`) equal the recorded values or are absent where the recording has
+* none; `mcp-session-id` is present exactly where recorded; the body has exactly the recorded
+* keys; the id is any JSON-RPC id of the accepted form where one is recorded; and `params` equal
+* the recorded ones except for JSON key order and the `_meta` client info's name and version
+* (and, on the second page of the paged listing, the cursor, checked by issuance). Everything
+* else is refused with a constant reason. The answer is the recorded one with only the request id
+* substituted where the recording carries the recorded request id (the top-level `id` of a JSON
+* answer, or of the SSE response event's payload), the session id (minted, or the request's) in
+* the `mcp-session-id` header, and the cursor of the current generation in `nextCursor`.
+*
+* @experimental
+*/
+const mcpEmulatorDrillKnobs = [
+	"discoverCarriesErrorResponse",
+	"discoverWithoutResultType",
+	"sessionIdNotVisibleAscii",
+	"discoverAnsweredTwice",
+	"writeToolMarkedReadOnly",
+	"readCallAnswersToolError",
+	"invalidCallAnswersRpcError",
+	"absentCallAnswersResult",
+	"unauthorizedWithoutChallenge"
+];
+const fieldOf = (value, key) => isJsonObject(value) ? value[key] : void 0;
+const exchangeOf = (fixtureId, index) => {
+	const exchange = mcpEmulatorFixtures.find((fixture) => fixture.id === fixtureId)?.exchanges.at(index);
+	if (exchange === void 0) throw new Error(`the MCP recordings have no exchange ${index} in ${fixtureId}`);
+	return exchange;
+};
+const modern = (caseId) => `${caseId}.modern.synthetic`;
+const legacy = (caseId) => `${caseId}.legacy.synthetic`;
+const recorded = {
+	modernDiscover: exchangeOf(modern("mcp.negotiation.era"), 0),
+	modernRejected: exchangeOf(modern("mcp.auth.rejected"), 0),
+	modernList: exchangeOf(modern("mcp.negotiation.era"), 1),
+	modernFirstPage: exchangeOf(modern("mcp.tools.list"), 1),
+	modernSecondPage: exchangeOf(modern("mcp.tools.list"), 2),
+	modernCallRead: exchangeOf(modern("mcp.tools.call-read"), -1),
+	modernCallToolError: exchangeOf(modern("mcp.tools.call-tool-error"), -1),
+	modernCallAbsent: exchangeOf(modern("mcp.errors.unknown-tool"), -1),
+	legacyDiscover: exchangeOf(legacy("mcp.negotiation.era"), 0),
+	legacyRejected: exchangeOf(legacy("mcp.auth.rejected"), 0),
+	legacyInitialize: exchangeOf(legacy("mcp.negotiation.era"), 1),
+	legacyInitialized: exchangeOf(legacy("mcp.negotiation.era"), 2),
+	legacyGet: exchangeOf(legacy("mcp.negotiation.era"), 3),
+	legacyList: exchangeOf(legacy("mcp.negotiation.era"), 4),
+	legacyCallRead: exchangeOf(legacy("mcp.tools.call-read"), -1),
+	legacyCallToolError: exchangeOf(legacy("mcp.tools.call-tool-error"), -1),
+	legacyCallAbsent: exchangeOf(legacy("mcp.errors.unknown-tool"), -1)
+};
+/** The cursor the paged listing records between its two pages. */
+const recordedCursor = (() => {
+	const cursor = fieldOf(fieldOf(recorded.modernSecondPage.request.body, "params"), "cursor");
+	if (!Predicate.isString(cursor)) throw new Error("the paged MCP listing records no cursor");
+	return cursor;
+})();
+const casesSending = (path, sends) => [...new Set(mcpEmulatorFixtures.flatMap((fixture) => fixture.endpoint === `https://mcp.example.test${path}` && fixture.exchanges.some((exchange) => sends(exchange.request)) ? [fixture.caseId] : []))];
+const rpcMethodOf = (request) => {
+	const method = fieldOf(request.body, "method");
+	return Predicate.isString(method) ? method : void 0;
+};
+const rpcRow = (path, method) => ({
+	method: "RPC",
+	path: `${mcpEmulatorOrigin}${path}#${method}`,
+	kind: "connector",
+	write: false,
+	caseIds: casesSending(path, (request) => request.method === "POST" && rpcMethodOf(request) === method),
+	evidence: "unverified"
+});
+const modernMethods = [
+	"server/discover",
+	"tools/list",
+	"tools/call"
+];
+const legacyMethods = [
+	"server/discover",
+	"initialize",
+	"notifications/initialized",
+	"tools/list",
+	"tools/call"
+];
+const modernRows = modernMethods.map((method) => rpcRow(mcpEmulatorModernPath, method));
+const legacyRows = legacyMethods.map((method) => rpcRow(mcpEmulatorLegacyPath, method));
+const getRow = {
+	method: "GET",
+	path: `${mcpEmulatorOrigin}${mcpEmulatorLegacyPath}`,
+	kind: "connector",
+	write: false,
+	caseIds: casesSending(mcpEmulatorLegacyPath, (request) => request.method === "GET"),
+	evidence: "unverified"
+};
+const rowOf = (path, method) => `${mcpEmulatorOrigin}${path}#${method}`;
+const isEventStream = (headers) => headers["content-type"] === "text/event-stream";
+/** A recorded answer as status, headers, and chunks (a JSON body is one chunk; none is none). */
+const answerOf = (response) => ({
+	status: response.status,
+	headers: response.headers,
+	chunks: "chunks" in response ? response.chunks : response.body === "" ? [] : [response.body]
+});
+const isResponseTo = (message, id) => isJsonObject(message) && message["id"] === id && ("result" in message || "error" in message);
+const dataPrefix = "data: ";
+/**
+* `answer` with the JSON-RPC response to `recordedId` (the top-level message of a JSON answer, or
+* the payload of the SSE event that carries it) replaced by `change` of it; every other chunk,
+* line, and event (notifications, `id:` lines) stays byte for byte.
+*/
+const mapResponse = (answer, recordedId, change) => {
+	const eventStream = isEventStream(answer.headers);
+	const chunks = answer.chunks.map((chunk) => {
+		if (!eventStream) {
+			const message = parseJsonText(chunk);
+			return isResponseTo(message, recordedId) ? JSON.stringify(change(message)) : chunk;
+		}
+		return chunk.split("\n").map((line) => {
+			if (!line.startsWith(dataPrefix)) return line;
+			const message = parseJsonText(line.slice(6));
+			return isResponseTo(message, recordedId) ? `${dataPrefix}${JSON.stringify(change(message))}` : line;
+		}).join("\n");
+	});
+	return {
+		...answer,
+		chunks
+	};
+};
+const recordedIdOf = (exchange) => {
+	const id = fieldOf(exchange.request.body, "id");
+	return Predicate.isString(id) || Predicate.isNumber(id) ? id : void 0;
+};
+/** The recorded answer of `exchange` with the request's id where it carries the recorded id. */
+const answerWithId = (exchange, id) => {
+	const answer = answerOf(exchange.response);
+	const recordedId = recordedIdOf(exchange);
+	if (recordedId === void 0 || id === void 0 || id === recordedId) return answer;
+	return mapResponse(answer, recordedId, (message) => ({
+		...message,
+		id
+	}));
+};
+/** `answer` with its `mcp-session-id` header (recorded on SSE answers) set to `session`. */
+const withSession = (answer, session) => answer.headers["mcp-session-id"] === void 0 ? answer : {
+	...answer,
+	headers: {
+		...answer.headers,
+		"mcp-session-id": session
+	}
+};
+/** The response message of an answer to `id` with `change` applied to its `result`. */
+const mapResult = (change) => (message) => {
+	const result = message["result"];
+	return isJsonObject(result) ? {
+		...message,
+		result: change(result)
+	} : message;
+};
+/**
+* Where a copied recording is not in the canonical form id substitution relies on: every JSON
+* answer body, and every SSE `data:` payload, must equal `JSON.stringify(JSON.parse(text))`, and
+* every SSE data line must start with `data: `. `makeMcpEmulator` throws on any problem, so a
+* recording copied in another form (escapes such as `\u00e9` or `\/`, numbers such as `1.0`,
+* spacing) fails loudly instead of answering bytes the substitution would rewrite.
+*/
+const mcpRecordingProblems = (fixtures) => fixtures.flatMap((fixture) => fixture.exchanges.flatMap(({ response }, index) => {
+	const where = `${fixture.id} exchange ${index}`;
+	const canonical = (text) => {
+		const parsed = parseJsonText(text);
+		return parsed !== void 0 && JSON.stringify(parsed) === text;
+	};
+	if (!("chunks" in response)) return response.body === "" || canonical(response.body) ? [] : [`${where}: the JSON body is not canonical`];
+	return response.chunks.flatMap((chunk, at) => chunk.split("\n").flatMap((line) => !line.startsWith("data") || line.startsWith(dataPrefix) && canonical(line.slice(6)) ? [] : [`${where} chunk ${at}: an SSE data line is not canonical`]));
+}));
+/** The MCP headers compared with the recording (absent where the recording has none). */
+const comparedHeaders = [
+	"accept",
+	"content-type",
+	"last-event-id",
+	"mcp-method",
+	"mcp-name",
+	"mcp-protocol-version"
+];
+const sessionHeader = "mcp-session-id";
+/** The `mcp-*` headers a recording carries; any other (such as `mcp-param-*`) is refused. */
+const recordedMcpHeaders = new Set([
+	"mcp-method",
+	"mcp-name",
+	"mcp-protocol-version",
+	sessionHeader
+]);
+/** Refuse an `mcp-*` header no recording carries (fail closed when the names are unknown). */
+const unrecordedMcpHeader = (request) => request.headerNames === void 0 || request.headerNames.some((name) => name.startsWith("mcp-") && !recordedMcpHeaders.has(name)) ? notEmulated("an mcp-* header no recording carries is not emulated") : void 0;
+const headerProblem = (request, recordedRequest, names) => {
+	for (const name of names) if (request.header(name) !== recordedRequest.headers[name]) return notEmulated(`the ${name} header must be the recorded value, or absent where none is`);
+	if (request.header(sessionHeader) === void 0 !== (recordedRequest.headers[sessionHeader] === void 0)) return notEmulated("mcp-session-id must be sent exactly where the recording sends one");
+};
+/**
+* A JSON-RPC request id of the emulated form: an integer from 0 to 2^53 - 1, or 1 to 64 printable
+* ASCII characters.
+*/
+const isMcpEmulatedRequestId = (id) => Predicate.isNumber(id) && Number.isSafeInteger(id) && id >= 0 || Predicate.isString(id) && /^[\x20-\x7E]{1,64}$/.test(id);
+/** Structural JSON equality, ignoring object key order. */
+const jsonEqual = (left, right) => {
+	if (Array.isArray(left)) return Array.isArray(right) && left.length === right.length && left.every((item, index) => {
+		const other = right[index];
+		return other !== void 0 && jsonEqual(item, other);
+	});
+	if (isJsonObject(left)) {
+		if (!isJsonObject(right)) return false;
+		const keys = Object.keys(left);
+		return keys.length === Object.keys(right).length && keys.every((key) => {
+			const value = left[key];
+			const other = right[key];
+			return Object.hasOwn(right, key) && value !== void 0 && other !== void 0 && jsonEqual(value, other);
+		});
+	}
+	return left === right;
+};
+const clientInfoKey = "io.modelcontextprotocol/clientInfo";
+const isClientInfo = (value) => isJsonObject(value) && Object.keys(value).length === 2 && Predicate.isString(value["name"]) && value["name"].length > 0 && Predicate.isString(value["version"]) && value["version"].length > 0;
+/**
+* The request params normalised for comparison with `recordedParams`: the `_meta` client info
+* replaced by the recorded one (when it is any non-empty name and version), and with `cursorFree`
+* the cursor replaced by the recorded one (when it is a string; checked by issuance at plan).
+*/
+const normalisedParams = (params, recordedParams, cursorFree) => {
+	if (!isJsonObject(params)) return notEmulated("params must be the recorded JSON object");
+	const meta = params["_meta"];
+	const recordedMeta = recordedParams["_meta"];
+	let normalised = params;
+	if (isJsonObject(recordedMeta) && recordedMeta[clientInfoKey] !== void 0) {
+		if (!isJsonObject(meta) || !isClientInfo(meta[clientInfoKey])) return notEmulated("the _meta client info must be a non-empty name and version only");
+		normalised = {
+			...normalised,
+			_meta: {
+				...meta,
+				[clientInfoKey]: recordedMeta[clientInfoKey]
+			}
+		};
+	}
+	if (cursorFree) {
+		if (!Predicate.isString(params["cursor"])) return notEmulated("the second page must send the cursor the first page issued");
+		normalised = {
+			...normalised,
+			cursor: recordedCursor
+		};
+	}
+	return normalised;
+};
+/**
+* The first candidate whose recorded request the JSON-RPC POST equals within the latitude, or
+* not emulated. Every candidate records the same method; candidates differ only in their params
+* and `mcp-name` (the recorded tool calls).
+*/
+const matchRpc = (request, candidates, options = {}) => {
+	const [first] = candidates;
+	if (first === void 0) return notEmulated("this JSON-RPC method is not emulated here");
+	const firstRequest = recorded[first].request;
+	const body = request.json;
+	const recordedBody = firstRequest.body;
+	if (!isJsonObject(recordedBody)) return notEmulated("this JSON-RPC method is not emulated here");
+	const common = unrecordedMcpHeader(request) ?? headerProblem(request, firstRequest, comparedHeaders.filter((name) => name !== "mcp-name"));
+	if (common !== void 0) return common;
+	if (!isJsonObject(body)) return notEmulated("JSON-RPC batches and non-object bodies are not emulated");
+	const keys = Object.keys(body);
+	const recordedKeys = Object.keys(recordedBody);
+	if (keys.length !== recordedKeys.length || keys.some((key) => !recordedKeys.includes(key))) return notEmulated("the JSON-RPC message must have exactly the recorded members");
+	if (body["jsonrpc"] !== "2.0") return notEmulated("jsonrpc must be \"2.0\"");
+	const id = body["id"];
+	if ("id" in recordedBody && !isMcpEmulatedRequestId(id)) return notEmulated("the request id must be an integer from 0 to 2^53 - 1 or 1 to 64 printable ASCII characters");
+	const cursor = options.cursorFree === true ? fieldOf(body["params"], "cursor") : void 0;
+	for (const key of candidates) {
+		const candidate = recorded[key].request;
+		const candidateBody = candidate.body;
+		if (!isJsonObject(candidateBody)) continue;
+		if (headerProblem(request, candidate, ["mcp-name"]) !== void 0) continue;
+		const recordedParams = candidateBody["params"];
+		if (recordedParams !== void 0) {
+			const params = isJsonObject(recordedParams) ? normalisedParams(body["params"], recordedParams, options.cursorFree === true) : notEmulated("params must be the recorded value");
+			if (isNotEmulated(params)) return params;
+			if (!jsonEqual(params, recordedParams)) continue;
+		}
+		return {
+			key,
+			id: isMcpEmulatedRequestId(id) ? id : void 0,
+			cursor: Predicate.isString(cursor) ? cursor : void 0
+		};
+	}
+	return notEmulated("params other than the recorded ones are not emulated");
+};
+/** Refuse any query parameter (no fixture records one). */
+const noQuery = (request) => request.rawQuery === void 0 || request.rawQuery === "" ? void 0 : notEmulated("query parameters are not emulated");
+const isReserved = (request, env) => request.bearerDigest === env.reservedDigest;
+const reservedOnlyOnProbe = "the reserved invalid credential is answered only on the era probe";
+const admission = (variant, admitted, plan) => ({
+	variant,
+	plan: (state, context) => plan(state, admitted, context.env)
+});
+/** A commit that answers `answer` and writes nothing. */
+const answerOnly = (answer) => streamedCommit(answer);
+const sessionOf = (state, admitted, phase) => state.sessions.find((session) => session.id === admitted.session && session.phase === phase);
+const unknownSession = (phase) => notEmulated(phase === "ready" ? "a request on no ready session of this emulator is not emulated" : "notifications/initialized on no initializing session of this emulator is not emulated");
+/** The JSON-RPC error the era drill adds to the discover answer (another id: the SDK skips it). */
+const drillErrorResponse = JSON.stringify({
+	jsonrpc: "2.0",
+	id: "yolk-emu-drill",
+	error: {
+		code: -32603,
+		message: "Synthetic drill error."
+	}
+});
+/** Drill transforms of an answer, by the recorded exchange it answers. */
+const drilled = (key, answer, id, env) => {
+	const drills = env.drills;
+	switch (key) {
+		case "modernDiscover": {
+			let next = answer;
+			if (drills.discoverWithoutResultType) next = mapResponse(next, id, mapResult(({ resultType: _resultType, ...result }) => result));
+			if (drills.discoverCarriesErrorResponse) next = {
+				...next,
+				chunks: next.chunks.map((chunk) => `[${drillErrorResponse},${chunk}]`)
+			};
+			if (drills.discoverAnsweredTwice) next = {
+				...next,
+				headers: {
+					...next.headers,
+					"content-type": "text/event-stream"
+				},
+				chunks: next.chunks.flatMap((chunk) => [`event: message\ndata: ${chunk}\n\n`, `event: message\ndata: ${chunk}\n\n`])
+			};
+			return next;
+		}
+		case "modernList":
+		case "modernFirstPage":
+		case "modernSecondPage":
+		case "legacyList": return drills.writeToolMarkedReadOnly ? mapResponse(answer, id, mapResult((result) => {
+			const tools = result["tools"];
+			return Array.isArray(tools) ? {
+				...result,
+				tools: tools.map((tool) => isJsonObject(tool) && tool["name"] === "create_synthetic_note" ? {
+					...tool,
+					annotations: { readOnlyHint: true }
+				} : tool)
+			} : result;
+		})) : answer;
+		case "modernCallRead":
+		case "legacyCallRead": return drills.readCallAnswersToolError ? mapResponse(answer, id, mapResult((result) => ({
+			...result,
+			isError: true
+		}))) : answer;
+		case "modernCallToolError":
+		case "legacyCallToolError": return drills.invalidCallAnswersRpcError ? mapResponse(answer, id, () => ({
+			jsonrpc: "2.0",
+			id,
+			error: {
+				code: -32602,
+				message: "Invalid arguments: noteId must be a string."
+			}
+		})) : answer;
+		case "modernCallAbsent":
+		case "legacyCallAbsent": {
+			if (!drills.absentCallAnswersResult) return answer;
+			const result = {
+				content: [{
+					type: "text",
+					text: "Synthetic drill result."
+				}],
+				isError: true
+			};
+			return mapResponse({
+				...answer,
+				status: 200
+			}, id, () => ({
+				jsonrpc: "2.0",
+				id,
+				result: key === "modernCallAbsent" ? {
+					...result,
+					resultType: "complete"
+				} : result
+			}));
+		}
+		case "modernRejected":
+		case "legacyRejected": {
+			if (!drills.unauthorizedWithoutChallenge) return answer;
+			const { "www-authenticate": _challenge, ...headers } = answer.headers;
+			return {
+				...answer,
+				headers
+			};
+		}
+		default: return answer;
+	}
+};
+/** The id the answer's response carries: the request's (substituted), else the recorded one. */
+const responseIdOf = (key, id) => id ?? recordedIdOf(recorded[key]);
+/** The recorded answer for `key`, with the request id substituted and any drill applied. */
+const recordedAnswer = (key, id, env) => {
+	const answer = answerWithId(recorded[key], id);
+	const responseId = responseIdOf(key, id);
+	return responseId === void 0 ? answer : drilled(key, answer, responseId, env);
+};
+/** The cursor value issued in the current generation (the recorded one in its first). */
+const cursorFor = (runtime) => (runtime.cursorFirstGeneration ?? runtime.generation) === runtime.generation ? recordedCursor : `${recordedCursor}.g${runtime.generation}`;
+const planModernList = (state, admitted, env) => {
+	if (state.modernListing === "one-page") return answerOnly(recordedAnswer("modernList", admitted.id, env));
+	const cursor = cursorFor(env.runtime);
+	const recordedPage = recordedAnswer("modernFirstPage", admitted.id, env);
+	const responseId = responseIdOf("modernFirstPage", admitted.id);
+	return streamedCommit(cursor === recordedCursor || responseId === void 0 ? recordedPage : mapResponse(recordedPage, responseId, mapResult((result) => ({
+		...result,
+		nextCursor: cursor
+	}))), () => {
+		env.runtime.cursorFirstGeneration ??= env.runtime.generation;
+		env.runtime.issuedCursor = cursor;
+	}, [cursor]);
+};
+const planModernSecondPage = (state, admitted, env) => state.modernListing === "two-pages" && env.runtime.issuedCursor !== void 0 && admitted.cursor === env.runtime.issuedCursor ? answerOnly(recordedAnswer("modernSecondPage", admitted.id, env)) : notEmulated("a cursor this emulator did not issue since the last reset or seed is not emulated");
+const planInitialize = (state, admitted, env) => {
+	const number = env.runtime.nextSession;
+	if (state.sessions.length >= 256 || !Number.isSafeInteger(number + 1)) return notEmulated("the emulator holds as many sessions as it takes");
+	const session = env.drills.sessionIdNotVisibleAscii ? `yolk-emu-session ${number}` : `${mcpEmulatorSessionPrefix}${number}`;
+	return streamedCommit(withSession(recordedAnswer("legacyInitialize", admitted.id, env), session), () => {
+		env.runtime.nextSession = number + 1;
+		state.sessions = [...state.sessions, {
+			id: session,
+			phase: "initializing"
+		}];
+	}, [session]);
+};
+const planInitialized = (state, admitted, env) => {
+	const session = sessionOf(state, admitted, "initializing");
+	if (session === void 0) return unknownSession("initializing");
+	return streamedCommit(recordedAnswer("legacyInitialized", void 0, env), () => {
+		state.sessions = state.sessions.map((held) => held.id === session.id ? {
+			id: held.id,
+			phase: "ready"
+		} : held);
+	});
+};
+/** A legacy answer on a ready session: the recorded answer with the session's id. */
+const planOnSession = (key) => (state, admitted, env) => {
+	const session = sessionOf(state, admitted, "ready");
+	return session === void 0 ? unknownSession("ready") : answerOnly(withSession(recordedAnswer(key, admitted.id, env), session.id));
+};
+const planAnswer = (key) => (_state, admitted, env) => answerOnly(recordedAnswer(key, admitted.id, env));
+const routeEvidenceOf = (method, path, variants) => ({
+	method,
+	path,
+	kind: "connector",
+	write: false,
+	caseIds: [...new Set(variants.flatMap((variant) => variant.caseIds))],
+	evidence: "unverified",
+	origin: mcpEmulatorOrigin,
+	variants
+});
+const admitted = (matched, request) => ({
+	...matched,
+	session: request.header(sessionHeader)
+});
+/** The route table: one wire route per recorded HTTP shape, each with its manifest variants. */
+const mcpApiRoutes = [
+	{
+		...routeEvidenceOf("POST", mcpEmulatorModernPath, modernRows),
+		body: "json",
+		admit: (request, env) => {
+			const query = noQuery(request);
+			if (query !== void 0) return query;
+			const method = fieldOf(request.json, "method");
+			const variant = (name) => rowOf(mcpEmulatorModernPath, name);
+			if (method === "server/discover") {
+				const matched = matchRpc(request, ["modernDiscover"]);
+				if (isNotEmulated(matched)) return matched;
+				return isReserved(request, env) ? admission(variant(method), admitted(matched, request), planAnswer("modernRejected")) : admission(variant(method), admitted(matched, request), planAnswer("modernDiscover"));
+			}
+			if (isReserved(request, env)) return notEmulated(reservedOnlyOnProbe);
+			if (method === "tools/list") {
+				const paged = fieldOf(fieldOf(request.json, "params"), "cursor") !== void 0;
+				const matched = paged ? matchRpc(request, ["modernSecondPage"], { cursorFree: true }) : matchRpc(request, ["modernList"]);
+				if (isNotEmulated(matched)) return matched;
+				return admission(variant(method), admitted(matched, request), paged ? planModernSecondPage : planModernList);
+			}
+			if (method === "tools/call") {
+				const matched = matchRpc(request, [
+					"modernCallRead",
+					"modernCallToolError",
+					"modernCallAbsent"
+				]);
+				if (isNotEmulated(matched)) return matched;
+				return admission(variant(method), admitted(matched, request), planAnswer(matched.key));
+			}
+			return notEmulated("this JSON-RPC method is not emulated on the modern profile");
+		}
+	},
+	{
+		...routeEvidenceOf("POST", mcpEmulatorLegacyPath, legacyRows),
+		body: "json",
+		admit: (request, env) => {
+			const query = noQuery(request);
+			if (query !== void 0) return query;
+			const method = fieldOf(request.json, "method");
+			const variant = (name) => rowOf(mcpEmulatorLegacyPath, name);
+			if (method === "server/discover") {
+				const matched = matchRpc(request, ["legacyDiscover"]);
+				if (isNotEmulated(matched)) return matched;
+				return isReserved(request, env) ? admission(variant(method), admitted(matched, request), planAnswer("legacyRejected")) : admission(variant(method), admitted(matched, request), planAnswer("legacyDiscover"));
+			}
+			if (isReserved(request, env)) return notEmulated(reservedOnlyOnProbe);
+			const single = (key, name, plan) => {
+				const matched = matchRpc(request, [key]);
+				return isNotEmulated(matched) ? matched : admission(variant(name), admitted(matched, request), plan);
+			};
+			if (method === "initialize") return single("legacyInitialize", method, planInitialize);
+			if (method === "notifications/initialized") return single("legacyInitialized", method, planInitialized);
+			if (method === "tools/list") return single("legacyList", method, planOnSession("legacyList"));
+			if (method === "tools/call") {
+				const matched = matchRpc(request, [
+					"legacyCallRead",
+					"legacyCallToolError",
+					"legacyCallAbsent"
+				]);
+				if (isNotEmulated(matched)) return matched;
+				return admission(variant(method), admitted(matched, request), planOnSession(matched.key));
+			}
+			return notEmulated("this JSON-RPC method is not emulated on the legacy profile");
+		}
+	},
+	{
+		...routeEvidenceOf("GET", mcpEmulatorLegacyPath, [getRow]),
+		body: "none",
+		admit: (request, env) => {
+			const query = noQuery(request);
+			if (query !== void 0) return query;
+			if (isReserved(request, env)) return notEmulated(reservedOnlyOnProbe);
+			const problem = unrecordedMcpHeader(request) ?? headerProblem(request, recorded.legacyGet.request, comparedHeaders);
+			if (problem !== void 0) return problem;
+			return admission(getRow.path, {
+				key: "legacyGet",
+				id: void 0,
+				cursor: void 0,
+				session: request.header(sessionHeader)
+			}, planOnSession("legacyGet"));
+		}
+	}
+];
+//#endregion
+export { isMcpEmulatedRequestId, mcpApiRoutes, mcpEmulatorDrillKnobs, mcpRecordingProblems };
+
+//# sourceMappingURL=api.mjs.map