@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/fixture-loader.js

@@ -1,6 +1,9 @@
-import { isAudioResponse, isContentWithToolCallsResponse, isEmbeddingResponse, isErrorResponse, isImageResponse, isJSONResponse, isLiveResponse, isTextResponse, isToolCallResponse, isTranscriptionResponse, isVideoResponse } from "./helpers.js";
+import { MCP_FAKES_ECHO_LIMIT } from "./constants.js";
+import { build, fixed, jsonText, msg, quote, within } from "./message-text.js";
+import { fixtureListTarget, isAudioResponse, isCombinedFixtureResponse, isEmbeddingResponse, isErrorResponse, isImageResponse, isJSONResponse, isLiveResponse, isTextResponse, isToolCallResponse, isTranscriptionResponse, isVideoResponse } from "./helpers.js";
 import { normalizeLiveFixture } from "./live-fixture.js";
 import { CHAOS_FIELDS, CHAOS_FIELD_NAMES, parseChaosField } from "./chaos.js";
+import { copyFixtureMisbehaviorPosition, parseMisbehavior, setFixtureMisbehaviorPosition, validateFixtureMisbehavior } from "./misbehavior.js";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 
@@ -32,7 +35,35 @@ function normalizeResponse(raw, liveOptions) {
 	});
 	return response;
 }
-function entryToFixture(entry, logger, liveOptions) {
+/**
+* @internal Normalize `responsesBlocks` and `customToolCalls` in place, for a
+* server with `responsesTools: "extended"`: stringify object `arguments` on
+* `toolCall` blocks, and give a `customToolCalls` entry with no `type` the
+* type `"custom"`. A custom call's free-text `input` is never stringified.
+* {@link normalizeResponse} leaves both keys as written, as 1.44.0 did.
+*/
+function normalizeResponsesToolsKeys(response) {
+	if (Array.isArray(response.responsesBlocks)) response.responsesBlocks = response.responsesBlocks.map((block) => {
+		const b = block;
+		if (b !== null && typeof b === "object" && b.type === "toolCall" && typeof b.arguments === "object" && b.arguments !== null) return {
+			...b,
+			arguments: JSON.stringify(b.arguments)
+		};
+		return block;
+	});
+	if (Array.isArray(response.customToolCalls)) response.customToolCalls = response.customToolCalls.map((tc) => {
+		const entry = tc;
+		return entry !== null && typeof entry === "object" && entry.type === void 0 ? {
+			...entry,
+			type: "custom"
+		} : tc;
+	});
+}
+var InvalidFixtureMatchError = class extends TypeError {};
+function entryToFixture(entry, logger, liveOptions, source) {
+	if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throw new TypeError("Fixture entry must be an object");
+	if (entry.match == null) throw new TypeError("Fixture match must be an object");
+	if (typeof entry.match !== "object" || Array.isArray(entry.match)) throw new InvalidFixtureMatchError("Fixture match must be an object");
 	const fixture = {
 		match: {
 			userMessage: entry.match.userMessage,
@@ -61,6 +92,19 @@ function entryToFixture(entry, logger, liveOptions) {
 		...entry.openRouterProcessing !== void 0 && { openRouterProcessing: entry.openRouterProcessing },
 		...entry.metadata !== void 0 && { metadata: entry.metadata }
 	};
+	if (source) setFixtureMisbehaviorPosition(fixture, `${source.file}#${source.index}`);
+	const heldToolNamespace = entry.match.toolNamespace !== void 0;
+	const response = fixture.response;
+	const heldResponseKeys = entry.match.endpoint !== "openai-live" && !isLiveResponse(entry.response) && typeof response === "object" && response !== null && ("customToolCalls" in response || "responsesBlocks" in response);
+	if (heldToolNamespace || heldResponseKeys) heldResponsesTools.set(fixture, {
+		...heldToolNamespace && { toolNamespace: entry.match.toolNamespace },
+		normalize: heldResponseKeys
+	});
+	if (entry.misbehavior !== void 0) heldFixtureMisbehavior.set(fixture, {
+		value: entry.misbehavior,
+		path: source ? `fixtures[${source.index}].misbehavior` : "misbehavior",
+		file: source?.file ?? null
+	});
 	if (fixture.recordedTimings) {
 		const rt = fixture.recordedTimings;
 		if (!Number.isFinite(rt.ttftMs) || rt.ttftMs < 0) rt.ttftMs = 0;
@@ -91,34 +135,100 @@ function warn(logger, msg, ...rest) {
 	if (logger) logger.warn(msg, ...rest);
 	else console.warn(`[fixture-loader] ${msg}`, ...rest);
 }
-function loadFixtureFile(filePath, logger, liveOptions) {
+/**
+* A parsed JSON value, or `null` when the file could not be read or parsed (warned).
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function readFixtureJson(filePath, logger) {
 	let raw;
 	try {
 		raw = readFileSync(filePath, "utf-8");
 	} catch (err) {
 		warn(logger, `Could not read file ${filePath}:`, err);
-		return [];
+		return null;
 	}
-	let parsed;
 	try {
-		parsed = JSON.parse(raw);
+		return { value: JSON.parse(raw) };
 	} catch (err) {
 		warn(logger, `Invalid JSON in ${filePath}:`, err);
-		return [];
+		return null;
 	}
+}
+/**
+* `parsed` is a JSON object with an own top-level `mcpFakes` key.
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function hasMcpFakesKey(parsed) {
+	return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && Object.prototype.hasOwnProperty.call(parsed, "mcpFakes");
+}
+/**
+* The LLM fixtures of a parsed file. A missing or non-array `fixtures` is
+* warned and gives none, except that a file with `mcpFakes` may leave
+* `fixtures` out (`fixturesOptional`, spec 5.4). An entry whose `match` is
+* not an object is skipped with a warning; any other bad entry throws.
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function fixturesOf(parsed, filePath, logger, liveOptions, fixturesOptional, source = filePath) {
+	if (fixturesOptional && typeof parsed === "object" && parsed !== null && !Object.prototype.hasOwnProperty.call(parsed, "fixtures")) return [];
 	if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.fixtures)) {
 		warn(logger, `Missing or invalid "fixtures" array in ${filePath}`);
 		return [];
 	}
-	return parsed.fixtures.map((e) => entryToFixture(e, logger, liveOptions));
+	const fixtures = [];
+	for (const [index, entry] of parsed.fixtures.entries()) try {
+		fixtures.push(entryToFixture(entry, logger, liveOptions, {
+			file: source,
+			index
+		}));
+	} catch (error) {
+		if (!(error instanceof InvalidFixtureMatchError)) throw error;
+		warn(logger, `Skipping fixture at index ${index} in ${filePath}: ${error.message}`);
+	}
+	return fixtures;
 }
-function loadFixturesFromDir(dirPath, logger, liveOptions) {
+/**
+* B13: the old loaders return LLM fixtures only, so a file with `mcpFakes`
+* fails loud instead of losing its fakes.
+*/
+function cannotCarryFakes(filePath) {
+	return new FixtureLoadError({
+		rule: "mcp-fakes/loader-cannot-carry-fakes",
+		file: filePath,
+		blockId: null,
+		entryId: null,
+		detail: msg`top-level "mcpFakes" key: loadFixtureFile and loadFixturesFromDir cannot carry MCP fakes; use loadFixtureFileWithServices or loadFixturesFromDirWithServices, or LLMock.loadFixtureFile or LLMock.loadFixtureDir`
+	});
+}
+/**
+* Load the LLM fixtures of one file. Throws a `FixtureLoadError` (rule
+* `mcp-fakes/loader-cannot-carry-fakes`) when the file has a top-level
+* `mcpFakes` key; use `loadFixtureFileWithServices` (fixture-loader-services.ts) for such files.
+*/
+function loadFixtureFile(filePath, logger, liveOptions) {
+	return loadLlmFixtureFile(filePath, filePath, logger, liveOptions);
+}
+function loadLlmFixtureFile(filePath, source, logger, liveOptions) {
+	const read = readFixtureJson(filePath, logger);
+	if (read === null) return [];
+	if (hasMcpFakesKey(read.value)) throw cannotCarryFakes(filePath);
+	return fixturesOf(read.value, filePath, logger, liveOptions, false, source);
+}
+/**
+* The `.json` files (sorted) and the subdirectories (sorted) of `dirPath`,
+* or `null` when it cannot be read (warned).
+*
+* @internal Shared with fixture-loader-services.ts.
+*/
+function listFixtureDir(dirPath, logger) {
 	let entries;
 	try {
 		entries = readdirSync(dirPath);
 	} catch (err) {
 		warn(logger, `Could not read directory ${dirPath}:`, err);
-		return [];
+		return null;
 	}
 	const jsonFiles = [];
 	const subdirs = [];
@@ -136,15 +246,34 @@ function loadFixturesFromDir(dirPath, logger, liveOptions) {
 		if (name.endsWith(".json")) jsonFiles.push(name);
 	}
 	jsonFiles.sort();
+	subdirs.sort();
+	return {
+		jsonFiles,
+		subdirs
+	};
+}
+/**
+* Load the LLM fixtures of every `.json` file under `dirPath`. Throws a
+* `FixtureLoadError` (rule `mcp-fakes/loader-cannot-carry-fakes`) on the
+* first file with a top-level `mcpFakes` key; use
+* `loadFixturesFromDirWithServices` (fixture-loader-services.ts) for such
+* directories.
+*/
+function loadFixturesFromDir(dirPath, logger, liveOptions) {
+	return loadLlmFixtureDir(dirPath, "", logger, liveOptions);
+}
+function loadLlmFixtureDir(dirPath, relDir, logger, liveOptions) {
+	const listing = listFixtureDir(dirPath, logger);
+	if (listing === null) return [];
 	const fixtures = [];
-	for (const name of jsonFiles) {
+	for (const name of listing.jsonFiles) {
 		const filePath = join(dirPath, name);
-		fixtures.push(...loadFixtureFile(filePath, logger, liveOptions));
+		fixtures.push(...loadLlmFixtureFile(filePath, relDir + name, logger, liveOptions));
 	}
-	subdirs.sort();
-	for (const sub of subdirs) fixtures.push(...loadFixturesFromDir(join(dirPath, sub), logger, liveOptions));
+	for (const sub of listing.subdirs) fixtures.push(...loadLlmFixtureDir(join(dirPath, sub), `${relDir}${sub}/`, logger, liveOptions));
 	return fixtures;
 }
+const INVALID_ARGUMENTS_HINT = "to send invalid JSON on purpose, use `misbehavior: tool-args-invalid-json`";
 /**
 * Render a ref-carrying finding's message with each named index passed through
 * `renderIndex`. With `String` it reproduces the message `validateFixtures`
@@ -195,6 +324,98 @@ function validateWebSearches(response, fixtureIndex, results) {
 		});
 	}
 }
+/**
+* Path (`customToolCalls[j]` or `responsesBlocks[j]`) of the first custom
+* tool call a static fixture response carries, or undefined. Factory
+* responses are skipped.
+*/
+function firstCustomToolCallPath(response) {
+	if (response === null || typeof response !== "object") return void 0;
+	const r = response;
+	if (Array.isArray(r.customToolCalls) && r.customToolCalls.length > 0) return "customToolCalls[0]";
+	if (Array.isArray(r.responsesBlocks)) {
+		const j = r.responsesBlocks.findIndex((b) => b !== null && typeof b === "object" && b.type === "customToolCall");
+		if (j >= 0) return `responsesBlocks[${j}]`;
+	}
+}
+/**
+* Checks for the OpenAI Responses keys `customToolCalls` and
+* `responsesBlocks`. Both are new, so their findings never touch a fixture an
+* earlier release accepted. A custom tool call takes a non-empty string
+* `name`, a string `input` (empty: warning), no `arguments`, a string `id`
+* when present and a non-empty string `namespace` when present.
+* `responsesBlocks` follows the `blocks` rules plus `customToolCall` blocks,
+* and may not be combined with `blocks`.
+*/
+function validateResponsesToolKeys(response, fixtureIndex, results) {
+	if (response === null || typeof response !== "object") return;
+	const r = response;
+	const error = (message) => results.push({
+		severity: "error",
+		fixtureIndex,
+		message
+	});
+	const warning = (message) => results.push({
+		severity: "warning",
+		fixtureIndex,
+		message
+	});
+	const checkCustom = (tc, path) => {
+		if (typeof tc.name !== "string" || tc.name === "") error(`${path}.name must be a non-empty string`);
+		if (typeof tc.input !== "string") error(`${path}.input must be a string for a custom tool call`);
+		else if (tc.input === "") warning(`${path}.input is empty`);
+		if (tc.arguments !== void 0) error(`${path}.arguments is not valid on a custom tool call; use input`);
+		if (tc.id !== void 0 && typeof tc.id !== "string") error(`${path}.id must be a string, got ${typeof tc.id}`);
+		if (tc.namespace !== void 0 && (typeof tc.namespace !== "string" || tc.namespace === "")) error(`${path}.namespace must be a non-empty string`);
+	};
+	if (r.customToolCalls !== void 0) if (!Array.isArray(r.customToolCalls)) error(`customToolCalls must be an array, got ${typeof r.customToolCalls}`);
+	else r.customToolCalls.forEach((entry, j) => {
+		if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+			error(`customToolCalls[${j}] must be an object`);
+			return;
+		}
+		const tc = entry;
+		if (tc.type !== void 0 && tc.type !== "custom") error(`customToolCalls[${j}].type must be "custom" when present`);
+		checkCustom(tc, `customToolCalls[${j}]`);
+	});
+	if (r.responsesBlocks === void 0) return;
+	if (!Array.isArray(r.responsesBlocks)) {
+		error(`responsesBlocks must be an array, got ${typeof r.responsesBlocks}`);
+		return;
+	}
+	if (Array.isArray(r.blocks) && r.blocks.length > 0 && r.responsesBlocks.length > 0) error("blocks and responsesBlocks cannot both be set; use responsesBlocks alone");
+	r.responsesBlocks.forEach((entry, j) => {
+		const path = `responsesBlocks[${j}]`;
+		if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+			error(`${path} must be an object`);
+			return;
+		}
+		const block = entry;
+		if (block.type === "text") {
+			if (typeof block.text !== "string") error(`${path}.text must be a string`);
+			return;
+		}
+		if (block.type === "customToolCall") {
+			checkCustom(block, path);
+			return;
+		}
+		if (block.type !== "toolCall") {
+			error(`${path}.type must be "text", "toolCall" or "customToolCall", got ${JSON.stringify(block.type)}`);
+			return;
+		}
+		if (typeof block.name !== "string" || block.name === "") error(`${path}.name must be a non-empty string`);
+		if (block.id !== void 0 && typeof block.id !== "string") error(`${path}.id must be a string, got ${typeof block.id}`);
+		if (block.input !== void 0) error(`${path}.input is only valid on a "customToolCall" block`);
+		if (block.namespace !== void 0 && (typeof block.namespace !== "string" || block.namespace === "")) error(`${path}.namespace must be a non-empty string`);
+		const args = block.arguments;
+		if (typeof args === "string") try {
+			JSON.parse(args);
+		} catch {
+			error(`${path}.arguments is not valid JSON: ${args}; ${INVALID_ARGUMENTS_HINT}`);
+		}
+		else if (args === null || typeof args !== "object") error(`${path}.arguments must be a string or an object`);
+	});
+}
 function validateBlocks(response, fixtureIndex, results) {
 	if (response.blocks === void 0) return;
 	if (!Array.isArray(response.blocks)) {
@@ -246,7 +467,7 @@ function validateBlocks(response, fixtureIndex, results) {
 				results.push({
 					severity: "error",
 					fixtureIndex,
-					message: `blocks[${j}].arguments is not valid JSON: ${block.arguments}`
+					message: `blocks[${j}].arguments is not valid JSON: ${block.arguments}; ${INVALID_ARGUMENTS_HINT}`
 				});
 			}
 			else if (typeof block.arguments !== "object" || block.arguments === null) results.push({
@@ -366,13 +587,14 @@ function claimOneShotError(fixtures, fixture) {
 * generation means the queue was cleared or reset while the claim was parked
 * (in the chaos-latency await) and the claim is stale — re-arming it would
 * plant the previous test's injection in the next test's freshly reset queue.
-* Keyed by array identity: every clear path preserves the array reference
-* (`length = 0`), so the counter follows the live queue.
+* Keyed by the caller's array (a server's own list resolves to it): every
+* clear path preserves the array reference (`length = 0`), so the counter
+* follows the live queue.
 */
 const fixtureQueueGeneration = /* @__PURE__ */ new WeakMap();
 const oneShotClaimGeneration = /* @__PURE__ */ new WeakMap();
 function queueGeneration(fixtures) {
-	return fixtureQueueGeneration.get(fixtures) ?? 0;
+	return fixtureQueueGeneration.get(fixtureListTarget(fixtures)) ?? 0;
 }
 /**
 * Empty a fixture queue in place (array identity preserved — the running
@@ -384,7 +606,7 @@ function queueGeneration(fixtures) {
 */
 function clearFixtureQueue(fixtures) {
 	fixtures.length = 0;
-	fixtureQueueGeneration.set(fixtures, queueGeneration(fixtures) + 1);
+	fixtureQueueGeneration.set(fixtureListTarget(fixtures), queueGeneration(fixtures) + 1);
 }
 /**
 * Re-arm a one-shot error that was claimed for a request which then ended
@@ -428,8 +650,25 @@ function validateFixtures(fixtures, liveOptions) {
 	const results = [];
 	const seenUserMessages = /* @__PURE__ */ new Map();
 	for (let i = 0; i < fixtures.length; i++) {
-		const f = fixtures[i];
+		const original = fixtures[i];
+		const f = responsesToolsExtendedFixtures.has(original) ? original : withoutResponsesToolsKeys(original);
 		const response = f.response;
+		const misbehaviorIssue = misbehaviorEnabledFixtures.has(original) ? validateFixtureMisbehavior(original, `fixtures[${i}].misbehavior`) : void 0;
+		if (misbehaviorIssue) results.push({
+			severity: "error",
+			fixtureIndex: i,
+			message: misbehaviorIssue.message
+		});
+		else if (misbehaviorEnabledFixtures.has(original) && f.misbehavior !== void 0) {
+			const parsed = parseMisbehavior(f.misbehavior);
+			if (parsed.ok && parsed.config.seed === void 0) {
+				for (const fault of parsed.config.faults) if (fault.rate !== void 0 && fault.rate < 1 && fault.times === void 0) results.push({
+					severity: "warning",
+					fixtureIndex: i,
+					message: "probabilistic fault without a seed is reproducible only per test id order; set seed to pin it"
+				});
+			}
+		}
 		if (typeof response !== "function" && (isLiveResponse(response) || f.match.endpoint === "openai-live")) try {
 			normalizeLiveFixture(response, liveOptions);
 		} catch (error) {
@@ -440,12 +679,13 @@ function validateFixtures(fixtures, liveOptions) {
 			});
 		}
 		if (typeof response === "function") {} else {
-			if (!isContentWithToolCallsResponse(response) && !isTextResponse(response) && !isToolCallResponse(response) && !isErrorResponse(response) && !isEmbeddingResponse(response) && !isImageResponse(response) && !isAudioResponse(response) && !isTranscriptionResponse(response) && !isVideoResponse(response) && !isJSONResponse(response) && !isLiveResponse(response)) results.push({
+			if (!isCombinedFixtureResponse(response) && !isTextResponse(response) && !isToolCallResponse(response) && !isErrorResponse(response) && !isEmbeddingResponse(response) && !isImageResponse(response) && !isAudioResponse(response) && !isTranscriptionResponse(response) && !isVideoResponse(response) && !isJSONResponse(response) && !isLiveResponse(response)) results.push({
 				severity: "error",
 				fixtureIndex: i,
 				message: "response is not a recognized type (must have content, toolCalls, error, embedding, image, audio, transcription, video, json, or live)"
 			});
-			const hasNonEmptyBlocks = Array.isArray(response.blocks) && response.blocks.length > 0;
+			const hasNonEmptyBlocks = Array.isArray(response.blocks) && response.blocks.length > 0 || Array.isArray(response.responsesBlocks) && response.responsesBlocks.length > 0;
+			const hasCustomToolCalls = Array.isArray(response.customToolCalls) && response.customToolCalls.length > 0;
 			if (isTextResponse(response)) {
 				if (response.content === "" && !hasNonEmptyBlocks) results.push({
 					severity: "error",
@@ -455,7 +695,7 @@ function validateFixtures(fixtures, liveOptions) {
 				validateReasoning(response, i, results);
 				validateWebSearches(response, i, results);
 			}
-			if (isContentWithToolCallsResponse(response)) {
+			if (isCombinedFixtureResponse(response)) {
 				if (typeof response.content === "string") {
 					if (response.content === "" && !hasNonEmptyBlocks) results.push({
 						severity: "error",
@@ -464,7 +704,7 @@ function validateFixtures(fixtures, liveOptions) {
 					});
 				}
 				if (Array.isArray(response.toolCalls)) {
-					if (response.toolCalls.length === 0) results.push({
+					if (response.toolCalls.length === 0 && !hasCustomToolCalls) results.push({
 						severity: "warning",
 						fixtureIndex: i,
 						message: "toolCalls array is empty — fixture will never produce tool calls"
@@ -482,7 +722,7 @@ function validateFixtures(fixtures, liveOptions) {
 							results.push({
 								severity: "error",
 								fixtureIndex: i,
-								message: `toolCalls[${j}].arguments is not valid JSON: ${tc.arguments}`
+								message: `toolCalls[${j}].arguments is not valid JSON: ${tc.arguments}; ${INVALID_ARGUMENTS_HINT}`
 							});
 						}
 					}
@@ -491,8 +731,9 @@ function validateFixtures(fixtures, liveOptions) {
 				validateWebSearches(response, i, results);
 			}
 			validateBlocks(response, i, results);
+			validateResponsesToolKeys(response, i, results);
 			if (isToolCallResponse(response)) {
-				if (response.toolCalls.length === 0) results.push({
+				if (response.toolCalls.length === 0 && !hasCustomToolCalls) results.push({
 					severity: "warning",
 					fixtureIndex: i,
 					message: "toolCalls array is empty — fixture will never produce tool calls"
@@ -510,7 +751,7 @@ function validateFixtures(fixtures, liveOptions) {
 						results.push({
 							severity: "error",
 							fixtureIndex: i,
-							message: `toolCalls[${j}].arguments is not valid JSON: ${tc.arguments}`
+							message: `toolCalls[${j}].arguments is not valid JSON: ${tc.arguments}; ${INVALID_ARGUMENTS_HINT}`
 						});
 					}
 				}
@@ -561,7 +802,7 @@ function validateFixtures(fixtures, liveOptions) {
 					message: `audio.contentType must be a string, got ${typeof audioObj.contentType}`
 				});
 			}
-			if (isTextResponse(response) || isToolCallResponse(response) || isContentWithToolCallsResponse(response)) {
+			if (isTextResponse(response) || isToolCallResponse(response) || isCombinedFixtureResponse(response)) {
 				const r = response;
 				if (r.id !== void 0 && typeof r.id !== "string") results.push({
 					severity: "error",
@@ -731,6 +972,29 @@ function validateFixtures(fixtures, liveOptions) {
 				message: "match.toolResultContains must be a non-empty string"
 			});
 		}
+		if (f.match.toolNamespace !== void 0) {
+			if (typeof f.match.toolNamespace !== "string") results.push({
+				severity: "error",
+				fixtureIndex: i,
+				message: `match.toolNamespace must be a string, got ${typeof f.match.toolNamespace}`
+			});
+			else if (f.match.toolNamespace.length === 0) results.push({
+				severity: "error",
+				fixtureIndex: i,
+				message: "match.toolNamespace must be a non-empty string"
+			});
+		}
+		if (typeof f.match.toolNamespace === "string" && f.match.toolNamespace !== "" && f.match.endpoint !== void 0 && f.match.endpoint !== "chat") results.push({
+			severity: "warning",
+			fixtureIndex: i,
+			message: `match.toolNamespace never matches with endpoint ${JSON.stringify(f.match.endpoint)} — only OpenAI Responses requests (endpoint "chat") carry tool namespaces`
+		});
+		const customCallPath = f.match.endpoint !== void 0 && f.match.endpoint !== "chat" ? firstCustomToolCallPath(f.response) : void 0;
+		if (customCallPath !== void 0) results.push({
+			severity: "warning",
+			fixtureIndex: i,
+			message: `${customCallPath} is a custom tool call, which only OpenAI Responses requests (endpoint "chat") can carry — endpoint ${JSON.stringify(f.match.endpoint)} never serves it, so a request that matches this fixture gets an error instead`
+		});
 		if (f.match.systemMessage !== void 0) {
 			const sm = f.match.systemMessage;
 			if (typeof sm === "string") {} else if (Array.isArray(sm)) {
@@ -771,7 +1035,8 @@ function validateFixtures(fixtures, liveOptions) {
 				m.context,
 				m.sequenceIndex,
 				m.turnIndex,
-				m.hasToolResult
+				m.hasToolResult,
+				...m.toolNamespace !== void 0 ? [`toolNamespace=${m.toolNamespace}`] : []
 			].map((v) => v === void 0 ? "" : String(v)).join("|");
 			const prev = seenUserMessages.get(dedupKey);
 			if (prev !== void 0) {
@@ -789,7 +1054,7 @@ function validateFixtures(fixtures, liveOptions) {
 			} else seenUserMessages.set(dedupKey, i);
 		}
 		const match = f.match;
-		if (!(match.endpoint !== void 0 || match.context !== void 0 || match.userMessage !== void 0 || match.systemMessage !== void 0 || match.inputText !== void 0 || match.responseFormat !== void 0 || match.toolCallId !== void 0 || match.toolResultContains !== void 0 || match.toolName !== void 0 || match.model !== void 0 || match.predicate !== void 0 || match.turnIndex !== void 0 || match.sequenceIndex !== void 0 || match.hasToolResult !== void 0) && i < fixtures.length - 1) {
+		if (!(match.endpoint !== void 0 || match.context !== void 0 || match.userMessage !== void 0 || match.systemMessage !== void 0 || match.inputText !== void 0 || match.responseFormat !== void 0 || match.toolCallId !== void 0 || match.toolResultContains !== void 0 || match.toolName !== void 0 || match.toolNamespace !== void 0 || match.model !== void 0 || match.predicate !== void 0 || match.turnIndex !== void 0 || match.sequenceIndex !== void 0 || match.hasToolResult !== void 0) && i < fixtures.length - 1) {
 			const ref = {
 				rule: "catch-all-not-last",
 				shadowsFrom: i + 1,
@@ -805,7 +1070,253 @@ function validateFixtures(fixtures, liveOptions) {
 	}
 	return results;
 }
+/**
+* `text` with every run of line breaks, and the spaces around it, folded to
+* one space: CR, LF, VT, FF, NEL, and the Unicode line and paragraph
+* separators.
+*/
+function oneLine(text) {
+	return text.replace(/\s*[\r\n\v\f\u0085\u2028\u2029]+\s*/g, " ");
+}
+/**
+* The `detail` as a `FixtureLoadError` message adds it: built in a budget of
+* its own, cut to at most `MCP_FAKES_ECHO_LIMIT` chars in all, with each of
+* its user parts cut once. A text detail is folded onto one line, gets the
+* escaping of every JSON text part (`jsonText`: each control char left, C0,
+* DEL or C1, and the line and paragraph separators as `\uXXXX`) and is cut
+* as JSON text (it is
+* made of fixed text, paths and quoted values, where a backslash only starts
+* a JSON escape; a stray one only moves the cut back a few chars).
+*/
+function capPart(detail) {
+	return within(MCP_FAKES_ECHO_LIMIT, typeof detail === "string" ? msg`${jsonText(oneLine(detail))}` : detail);
+}
+/**
+* One `file`, `blockId` or `entryId` as the message names it: JSON-quoted
+* (control chars escaped, so a name can neither break the line nor pose as
+* the message layout), and cut once to `MCP_FAKES_ECHO_LIMIT` chars at most.
+* An empty string is `""`, so the message names every part `toJSON()` keeps.
+*/
+function namePart(text) {
+	return msg`${quote(text)}`;
+}
+/**
+* The message of a `FixtureLoadError` or `MisbehaviorConfigError`: the
+* `file`, every non-null `blockId` and `entryId`, then `[rule] detail`.
+*/
+function loadErrorMessage(init) {
+	return oneLine(build(msg`${init.file === null ? msg`<no file>` : namePart(init.file)}${init.blockId == null ? msg`` : msg`, block ${namePart(init.blockId)}`}${init.entryId == null ? msg`` : msg`, entry ${namePart(init.entryId)}`}: [${fixed(init.rule)}] ${capPart(init.detail)}`));
+}
+/**
+* Thrown for a fixture-load case aimock cannot honor (fail-loud rule). Only
+* MCP fakes use it (misbehavior throws its own `MisbehaviorConfigError`);
+* other fixture-loader paths log warnings.
+* `blockId` and `entryId` are own properties only when supplied, so
+* `toJSON()` (the control API's HTTP 400 `details`) omits them otherwise.
+* The message names `file` and every non-null `blockId` and `entryId`, an
+* empty string as `""`, so it agrees with `toJSON()`. `options.cause` (the
+* standard `ErrorOptions`) keeps the underlying error, such as a JSON parse
+* failure; `toJSON()` leaves it out.
+*/
+var FixtureLoadError = class extends Error {
+	/** Typed `string` so a subclass can set its own name. */
+	name = "FixtureLoadError";
+	rule;
+	file;
+	constructor(init, options) {
+		super(loadErrorMessage(init), options);
+		this.rule = init.rule;
+		this.file = init.file;
+		if (init.blockId !== void 0) Object.defineProperty(this, "blockId", {
+			value: init.blockId,
+			enumerable: true,
+			writable: false
+		});
+		if (init.entryId !== void 0) Object.defineProperty(this, "entryId", {
+			value: init.entryId,
+			enumerable: true,
+			writable: false
+		});
+	}
+	toJSON() {
+		const json = {
+			name: this.name,
+			rule: this.rule,
+			file: this.file,
+			message: this.message
+		};
+		if (this.blockId !== void 0) json.blockId = this.blockId;
+		if (this.entryId !== void 0) json.entryId = this.entryId;
+		return json;
+	}
+};
+/**
+* Thrown for an invalid fixture `misbehavior` key, or one that cannot apply
+* to its fixture, on a server with misbehavior enabled (`enableMisbehavior:
+* true`, CLI `--misbehavior`). Without that opt-in the key is unused data
+* and nothing throws. The message has the `FixtureLoadError` layout:
+* `"<file>": [<rule>] <detail>`.
+*/
+var MisbehaviorConfigError = class extends Error {
+	name = "MisbehaviorConfigError";
+	rule;
+	file;
+	constructor(init) {
+		super(loadErrorMessage(init));
+		this.rule = init.rule;
+		this.file = init.file;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			rule: this.rule,
+			file: this.file,
+			message: this.message
+		};
+	}
+};
+const heldFixtureMisbehavior = /* @__PURE__ */ new WeakMap();
+const responsesToolsExtendedFixtures = /* @__PURE__ */ new WeakSet();
+const heldResponsesTools = /* @__PURE__ */ new WeakMap();
+/**
+* @internal Mark a fixture for a server with `responsesTools: "extended"`,
+* where that server made the fixture itself (its own load, `--validate`, the
+* control API): the held `match.toolNamespace` is applied and
+* `customToolCalls` / `responsesBlocks` are normalized in place, and
+* `validateFixtures` checks those keys. Idempotent. A fixture the caller
+* passed in is never marked: an extended server reads it through
+* {@link responsesToolsExtendedView}, so another server sharing it still sees
+* it as 1.44.0 loaded it.
+*/
+function markFixtureResponsesToolsExtended(fixture) {
+	responsesToolsExtendedFixtures.add(fixture);
+	const held = heldResponsesTools.get(fixture);
+	if (held === void 0) return;
+	heldResponsesTools.delete(fixture);
+	if (held.toolNamespace !== void 0) fixture.match = withHeldToolNamespace(fixture.match, held.toolNamespace);
+	if (held.normalize) normalizeResponsesToolsKeys(fixture.response);
+}
+/**
+* `match` with `toolNamespace` after `toolName`, in the same key order the
+* listing and journal have always shown in extended mode.
+*/
+function withHeldToolNamespace(match, toolNamespace) {
+	const rebuilt = {};
+	for (const [key, value] of Object.entries(match)) {
+		rebuilt[key] = value;
+		if (key === "toolName") rebuilt.toolNamespace = toolNamespace;
+	}
+	if (!("toolNamespace" in rebuilt)) rebuilt.toolNamespace = toolNamespace;
+	return rebuilt;
+}
+const extendedViews = /* @__PURE__ */ new WeakMap();
+/** Each extended view's fixture, so identity bookkeeping can name the caller's object. */
+const extendedViewSources = /* @__PURE__ */ new WeakMap();
+/**
+* @internal The fixture an extended view was made from
+* ({@link responsesToolsExtendedView}); any other fixture is itself. An
+* extended server counts and journals the caller's fixture, not its view, so
+* the identity APIs (`getFixtureMatchCount`, `findByFixture`, the count-map
+* keys, `JournalEntry.response.fixture`) take the object the caller passed in.
+*/
+function responsesToolsViewSource(fixture) {
+	return extendedViewSources.get(fixture) ?? fixture;
+}
+/**
+* @internal The fixture as a server with `responsesTools: "extended"` reads
+* it. A fixture with held keys gets a separate object, one per fixture, with
+* `match.toolNamespace` applied and `customToolCalls` / `responsesBlocks`
+* normalized, as {@link markFixtureResponsesToolsExtended} would leave it.
+* The fixture itself is not changed, so a legacy server that shares it is
+* unaffected. Every other property is read from the fixture on each call.
+* A fixture with nothing held is returned as it is.
+*/
+function responsesToolsExtendedView(fixture) {
+	const held = heldResponsesTools.get(fixture);
+	if (held === void 0) return fixture;
+	let cached = extendedViews.get(fixture);
+	if (cached === void 0) {
+		cached = { view: {} };
+		responsesToolsExtendedFixtures.add(cached.view);
+		extendedViewSources.set(cached.view, fixture);
+		extendedViews.set(fixture, cached);
+	}
+	if (cached.viewMatch === void 0 || cached.match !== fixture.match) {
+		cached.match = fixture.match;
+		cached.viewMatch = held.toolNamespace !== void 0 ? withHeldToolNamespace(fixture.match, held.toolNamespace) : fixture.match;
+	}
+	if (!("viewResponse" in cached) || cached.response !== fixture.response) {
+		cached.response = fixture.response;
+		let viewResponse = fixture.response;
+		if (held.normalize && typeof viewResponse === "object" && viewResponse !== null) {
+			const copy = { ...viewResponse };
+			normalizeResponsesToolsKeys(copy);
+			viewResponse = copy;
+		}
+		cached.viewResponse = viewResponse;
+	}
+	const view = cached.view;
+	const source = fixture;
+	for (const key of Object.keys(view)) if (!(key in source)) delete view[key];
+	for (const key of Object.keys(source)) view[key] = key === "match" ? cached.viewMatch : key === "response" ? cached.viewResponse : source[key];
+	copyFixtureMisbehaviorPosition(fixture, cached.view);
+	return cached.view;
+}
+/**
+* The fixture as 1.44.0 saw it: without `match.toolNamespace`,
+* `customToolCalls` and `responsesBlocks`. Returns the same object when none
+* is set; factory responses are left as they are.
+*/
+function withoutResponsesToolsKeys(fixture) {
+	let match = fixture.match;
+	if ("toolNamespace" in match) {
+		const copy = { ...match };
+		delete copy.toolNamespace;
+		match = copy;
+	}
+	let response = fixture.response;
+	if (typeof response !== "function" && response !== null && typeof response === "object" && ("customToolCalls" in response || "responsesBlocks" in response)) {
+		const copy = { ...response };
+		delete copy.customToolCalls;
+		delete copy.responsesBlocks;
+		response = copy;
+	}
+	if (match === fixture.match && response === fixture.response) return fixture;
+	return {
+		...fixture,
+		match,
+		response
+	};
+}
+const misbehaviorEnabledFixtures = /* @__PURE__ */ new WeakSet();
+/**
+* @internal Recognize the `misbehavior` key a loaded fixture entry carried,
+* for a server with misbehavior enabled: parse it onto the fixture (in place;
+* the loader made the object) and check it applies, or throw
+* `MisbehaviorConfigError`. A fixture with no held key is left unchanged.
+*/
+function enableHeldFixtureMisbehavior(fixture) {
+	const held = heldFixtureMisbehavior.get(fixture);
+	if (held === void 0) return;
+	const parsed = parseMisbehavior(held.value, held.path);
+	if (parsed.ok) fixture.misbehavior = parsed.config;
+	const issue = parsed.ok ? validateFixtureMisbehavior(fixture, held.path) : parsed.issue;
+	if (issue) throw new MisbehaviorConfigError({
+		rule: issue.rule,
+		file: held.file,
+		detail: issue.message
+	});
+	heldFixtureMisbehavior.delete(fixture);
+	misbehaviorEnabledFixtures.add(fixture);
+}
+/**
+* @internal Mark a fixture whose `misbehavior` a server with misbehavior
+* enabled has recognized, so `validateFixtures` checks it.
+*/
+function markFixtureMisbehaviorEnabled(fixture) {
+	misbehaviorEnabledFixtures.add(fixture);
+}
 
 //#endregion
-export { INJECTED_STATUS_RANGE, claimOneShotError, clearFixtureQueue, entryToFixture, isInjectableStatus, isOneShotError, loadFixtureFile, loadFixturesFromDir, normalizeResponse, queueOneShotError, releaseOneShotError, renderValidationRef, validateFixtures };
+export { FixtureLoadError, INJECTED_STATUS_RANGE, MisbehaviorConfigError, claimOneShotError, clearFixtureQueue, enableHeldFixtureMisbehavior, entryToFixture, fixturesOf, hasMcpFakesKey, isInjectableStatus, isOneShotError, listFixtureDir, loadFixtureFile, loadFixturesFromDir, markFixtureMisbehaviorEnabled, markFixtureResponsesToolsExtended, normalizeResponse, normalizeResponsesToolsKeys, queueOneShotError, readFixtureJson, releaseOneShotError, renderValidationRef, responsesToolsExtendedView, responsesToolsViewSource, validateFixtures };
 //# sourceMappingURL=fixture-loader.js.map