@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/validate-cli.js

@@ -1,7 +1,9 @@
-import { entryToFixture, renderValidationRef, validateFixtures } from "./fixture-loader.js";
+import { build, msg, plainText } from "./message-text.js";
+import { MisbehaviorConfigError, enableHeldFixtureMisbehavior, entryToFixture, hasMcpFakesKey, markFixtureResponsesToolsExtended, renderValidationRef, validateFixtures } from "./fixture-loader.js";
 import { Logger } from "./logger.js";
+import { McpFakeStore, McpFakesAddError, validateMcpFakes } from "./mcp-fakes.js";
 import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join, relative, resolve, sep } from "node:path";
 import { format, parseArgs } from "node:util";
 
 //#region src/validate-cli.ts
@@ -45,14 +47,9 @@ import { format, parseArgs } from "node:util";
 *    directory symlink that points back at a directory already being walked
 *    is reported once as a cycle, where the server recurses through it until
 *    the kernel returns ELOOP (~32 levels deep) and loads those levels'
-*    fixtures over and over. One diagnostic here has no counterpart there at
-*    all: an entry whose `match` is a string, a number, a boolean or an array
-*    converts, on both sides, into an EMPTY match — a catch-all answering
-*    every request — and the server loads it without a word. That is a server
-*    bug, not a rule this lint may quietly invent an error for, so it is a
-*    `[warning]` (which `--strict` promotes to a failure) rather than an
-*    error, and the fixture still goes on to the rules exactly as the server
-*    would build it.
+*    fixtures over and over. Malformed scalar or array matches are rejected
+*    before conversion, as they are by the server's fixture loader. The lint
+*    reports an entry error and continues validating valid siblings.
 *  - Equal: the `validateFixtures` rules themselves, because of the union
 *    pass above, and the zero-fixture rule — a run whose inputs yield no
 *    fixtures at all is an error here, matching the server's "No fixtures
@@ -132,6 +129,13 @@ pointing anywhere else is followed, as the server follows it.
 Options:
       --strict          Treat warnings as errors (exit 1 on warnings)
       --json            Emit a JSON report instead of human lines
+      --misbehavior     Check fixture misbehavior keys, as the server does with
+                        --misbehavior (without it they are not read)
+      --responses-tools <legacy|extended>
+                        With "extended", check match.toolNamespace,
+                        customToolCalls and responsesBlocks, as a server with
+                        --responses-tools extended reads them (default
+                        "legacy": they are not read)
   -h, --help            Show this help message
       --                Stop option parsing; every later argument is a path
                         (use this for a path that begins with "-")
@@ -271,6 +275,7 @@ function nonFixtureSkipReason(file) {
 	} catch {
 		return;
 	}
+	if (hasMcpFakesKey(parsed)) return void 0;
 	const asConfig = aimockConfigDescription(parsed);
 	if (asConfig !== void 0) return `not a fixture file — ${asConfig}`;
 	if (typeof parsed === "object" && parsed !== null && "fixtures" in parsed) return void 0;
@@ -428,9 +433,9 @@ function classifyEntry(entry) {
 		}).map((k) => `"${k}"`).join(" and ")} — ${ENTRY_SHAPE}`
 	};
 	if (typeof match !== "object" || Array.isArray(match)) return {
-		severity: "warning",
-		convertible: true,
-		why: `"match" is ${gotText(match)}, not an object — every match field reads as undefined, so this entry is an empty match: a CATCH-ALL answering every request. The server loads it the same way, so this warns rather than errors; --strict fails on it. ${ENTRY_SHAPE}`
+		severity: "error",
+		convertible: false,
+		why: `"match" is ${gotText(match)}, expected an object — ${ENTRY_SHAPE}`
 	};
 }
 /**
@@ -459,7 +464,7 @@ function unexpectedEntryFailure(index, err) {
 * cross-file union pass can append them and map its findings back to a file
 * and an entry index.
 */
-function validateOneFile(file, mention) {
+function validateOneFile(file, mention, source, misbehavior = false, extendedResponsesTools = false) {
 	const report = {
 		file,
 		mention,
@@ -471,6 +476,7 @@ function validateOneFile(file, mention) {
 	const sourceIndex = [];
 	const runErrors = [];
 	const identities = [];
+	const mcpFakes = [];
 	let raw;
 	try {
 		raw = readFileSync(file, "utf-8");
@@ -481,7 +487,8 @@ function validateOneFile(file, mention) {
 			fixtures,
 			indices: sourceIndex,
 			identities,
-			runErrors
+			runErrors,
+			mcpFakes
 		};
 	}
 	let parsed;
@@ -494,20 +501,48 @@ function validateOneFile(file, mention) {
 			fixtures,
 			indices: sourceIndex,
 			identities,
-			runErrors
+			runErrors,
+			mcpFakes
 		};
 	}
-	if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.fixtures)) {
+	const fakesDoc = hasMcpFakesKey(parsed) ? parsed : void 0;
+	const fixturesLeftOut = fakesDoc !== void 0 && !Object.prototype.hasOwnProperty.call(fakesDoc, "fixtures");
+	const badShape = !fixturesLeftOut && (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.fixtures));
+	if (badShape) {
 		const asConfig = aimockConfigDescription(parsed);
 		setFatal(report, asConfig === void 0 ? "Missing or invalid \"fixtures\" array (expected { \"fixtures\": [...] })" : `Missing or invalid "fixtures" array (expected { "fixtures": [...] }) — this is ${asConfig}`);
-		return {
-			report,
-			fixtures,
-			indices: sourceIndex,
-			identities,
-			runErrors
-		};
 	}
+	if (fakesDoc !== void 0) {
+		const fakes = fakesDoc.mcpFakes;
+		const validation = validateMcpFakes(fakes, source);
+		report.errors.push(...validation.errors.map(loadErrorFinding));
+		report.mcpFakeBlocks = 0;
+		const recorded = fakesDoc._warnings;
+		if (Array.isArray(recorded)) {
+			for (const w of recorded) if (typeof w === "string") report.warnings.push({ message: w });
+		}
+		if (validation.errors.length > 0) report.warnings.push(...validation.warnings.map(issueFinding));
+		else if (Array.isArray(fakes)) fakes.forEach((block, blockIndex) => {
+			mcpFakes.push({
+				source,
+				blockIndex,
+				raw: block
+			});
+		});
+		else mcpFakes.push({
+			source,
+			blockIndex: null,
+			raw: fakes
+		});
+	}
+	if (fixturesLeftOut || badShape) return {
+		report,
+		fixtures,
+		indices: sourceIndex,
+		identities,
+		runErrors,
+		mcpFakes
+	};
 	let entryIndex = 0;
 	const entryLogger = new CollectingLogger((message) => report.warnings.push({
 		index: entryIndex,
@@ -533,10 +568,19 @@ function validateOneFile(file, mention) {
 			report.warnings.push(finding);
 		}
 		try {
-			fixtures.push(entryToFixture(entries[index], entryLogger));
+			const fixture = entryToFixture(entries[index], entryLogger, void 0, {
+				file: source,
+				index
+			});
+			if (misbehavior) enableHeldFixtureMisbehavior(fixture);
+			if (extendedResponsesTools) markFixtureResponsesToolsExtended(fixture);
+			fixtures.push(fixture);
 			sourceIndex.push(index);
 		} catch (err) {
-			report.errors.push(unexpectedEntryFailure(index, err));
+			report.errors.push(err instanceof MisbehaviorConfigError ? {
+				index,
+				message: err.message
+			} : unexpectedEntryFailure(index, err));
 		}
 	}
 	report.fixtures = fixtures.length;
@@ -576,10 +620,22 @@ function validateOneFile(file, mention) {
 		fixtures,
 		indices: sourceIndex,
 		identities,
-		runErrors
+		runErrors,
+		mcpFakes
 	};
 }
 /**
+* A `FixtureLoadError` from an `mcpFakes` block as a file-level finding (no
+* fixture entry index): its message names the rule, file, block and entry.
+*/
+function loadErrorFinding(err) {
+	return { message: err.message };
+}
+/** An L8 shadowed-entry warning as a file-level finding. */
+function issueFinding(issue) {
+	return { message: issue.message };
+}
+/**
 * `#<index> ` for a finding that belongs to one entry; empty for a file-level
 * finding, which names no entry (see Finding.index). Shared by the human lines
 * and the failure summary so a reader of either can locate the same entry.
@@ -654,6 +710,7 @@ function runValidateCli(deps = {}) {
 			files: [],
 			run: {
 				fixtures: 0,
+				mcpFakeBlocks: 0,
 				errors: [message]
 			}
 		}, null, 2));
@@ -673,6 +730,11 @@ function runValidateCli(deps = {}) {
 					type: "boolean",
 					default: false
 				},
+				misbehavior: {
+					type: "boolean",
+					default: false
+				},
+				"responses-tools": { type: "string" },
 				help: {
 					type: "boolean",
 					short: "h",
@@ -695,6 +757,13 @@ function runValidateCli(deps = {}) {
 	}
 	const strict = values.strict === true;
 	const json = values.json === true;
+	const misbehavior = values.misbehavior === true;
+	const responsesTools = values["responses-tools"];
+	if (responsesTools !== void 0 && responsesTools !== "legacy" && responsesTools !== "extended") {
+		usageError(`invalid --responses-tools "${responsesTools}" (expected "legacy" or "extended").`);
+		return;
+	}
+	const extendedResponsesTools = responsesTools === "extended";
 	if (paths.length === 0) {
 		usageError("no fixture paths given.");
 		return;
@@ -735,7 +804,10 @@ function runValidateCli(deps = {}) {
 			});
 			continue;
 		}
-		targets.push(...entries);
+		for (const entry of entries) targets.push({
+			...entry,
+			source: relative(path, entry.file).split(sep).join("/")
+		});
 	}
 	const mentionKey = (file) => resolve(file);
 	const mentionCount = /* @__PURE__ */ new Map();
@@ -761,6 +833,8 @@ function runValidateCli(deps = {}) {
 	const reportedBySite = /* @__PURE__ */ new Map();
 	const fileIds = /* @__PURE__ */ new Map();
 	const runErrors = [];
+	const fakeStore = new McpFakeStore();
+	let mcpFakeBlocks = 0;
 	const siteKey = (fileId, index, severity, kind) => [
 		fileId,
 		index,
@@ -788,12 +862,24 @@ function runValidateCli(deps = {}) {
 		let indices = [];
 		let identities = [];
 		let fileRunErrors = [];
+		let mcpFakes = [];
 		const mention = nextMention(target.file);
 		try {
-			({report, fixtures, indices, identities, runErrors: fileRunErrors} = validateOneFile(target.file, mention));
+			({report, fixtures, indices, identities, runErrors: fileRunErrors, mcpFakes} = validateOneFile(target.file, mention, target.source ?? target.file, misbehavior, extendedResponsesTools));
 		} catch (err) {
 			report = fatalReport(target.file, mention, `Validation failed: ${errText(err)}`);
 		}
+		if (mcpFakes.length > 0) try {
+			const added = fakeStore.add(mcpFakes, { kind: "file" });
+			report.mcpFakeBlocks = mcpFakes.length;
+			mcpFakeBlocks += mcpFakes.length;
+			report.warnings.push(...added.warnings.map(issueFinding));
+		} catch (err) {
+			if (err instanceof McpFakesAddError) {
+				report.errors.push(...err.errors.map(loadErrorFinding));
+				report.warnings.push(...err.warnings.map(issueFinding));
+			} else report.errors.push({ message: build(msg`mcpFakes check failed: ${plainText(errText(err), Infinity)}`) });
+		}
 		reports.push(report);
 		runErrors.push(...fileRunErrors.map((e) => `${displayName(report)}: ${e}`));
 		const fileId = fileIds.size;
@@ -820,7 +906,7 @@ function runValidateCli(deps = {}) {
 	let noFixturesLoaded = false;
 	const causeAlreadyReported = reports.some((r) => r.fatal !== void 0 || r.errors.length > 0);
 	if (union.length === 0) {
-		if (!causeAlreadyReported) {
+		if (!causeAlreadyReported && mcpFakeBlocks === 0) {
 			runErrors.push("No fixtures loaded from any input — the server aborts startup on this under --validate-on-load/--strict");
 			noFixturesLoaded = true;
 		}
@@ -885,6 +971,7 @@ function runValidateCli(deps = {}) {
 			files: reports,
 			run: {
 				fixtures: union.length,
+				mcpFakeBlocks,
 				errors: runErrors
 			}
 		}, null, 2));
@@ -908,11 +995,14 @@ function runValidateCli(deps = {}) {
 				logWarning(`${name}: [warning] ${at(w)}${w.message}`);
 				emitDetail(w, logWarning);
 			}
-			if (r.errors.length === 0 && r.warnings.length === 0) if (r.fixtures === 0 && failed) {
-				const why = noFixturesLoaded ? "see the run-level error" : "the run failed elsewhere";
-				log(`${name}: ${r.fixtures} fixture(s), loaded nothing — ${why}`);
-			} else log(`${name}: OK (${r.fixtures} fixture(s))`);
-			else log(`${name}: ${r.fixtures} fixture(s), ${r.errors.length} error(s), ${r.warnings.length} warning(s)`);
+			if (r.errors.length === 0 && r.warnings.length === 0) {
+				const blocks = r.mcpFakeBlocks ?? 0;
+				if (r.fixtures === 0 && blocks === 0 && failed) {
+					const why = noFixturesLoaded ? "see the run-level error" : "the run failed elsewhere";
+					log(`${name}: ${r.fixtures} fixture(s), loaded nothing — ${why}`);
+				} else if (blocks > 0) log(build(msg`${plainText(name, Infinity)}: OK (${r.fixtures} fixture(s), ${blocks} mcpFakes block(s))`));
+				else log(`${name}: OK (${r.fixtures} fixture(s))`);
+			} else log(`${name}: ${r.fixtures} fixture(s), ${r.errors.length} error(s), ${r.warnings.length} warning(s)`);
 		}
 		for (const e of runErrors) logError(`[error] ${e}`);
 	}