@copilotkit/aimock 1.41.0 → 1.42.0

package/dist/server.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.cts","names":[],"sources":["../src/server.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;UAgIiB,cAAA;EAAA,MAAA,EACP,MAAA,CAAK,MADgB;EAAA,OAAA,EAEpB,OAFoB;KACrB,EAAA,MAAK;UACJ,EAEC,eAFD;aAEC,EACG,aADH;qBACG,EACQ,qBADR;cACQ,EACP,cADO;eACP,EACC,eADD;mBACC,EACI,mBADJ;;;AA+rCjB;;;;;UAAiB,eAAA;UACP;UACA;cACI;;iBAMQ,YAAA,WACV,qBACA,4BACD;;WAA+B;sBACtB,kBACjB,QAAQ"}
+{"version":3,"file":"server.d.cts","names":[],"sources":["../src/server.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;UAgJiB,cAAA;EAAA,MAAA,EACP,MAAA,CAAK,MADgB;EAAA,OAAA,EAEpB,OAFoB;KACrB,EAAA,MAAK;UACJ,EAEC,eAFD;aAEC,EACG,aADH;qBACG,EACQ,qBADR;cACQ,EACP,cADO;eACP,EACC,eADD;mBACC,EACI,mBADJ;;;AAqkDjB;;;;;UAAiB,eAAA;UACP;UACA;cACI;;iBAMQ,YAAA,WACV,qBACA,4BACD;;WAA+B;sBACtB,kBACjB,QAAQ"}

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;UAgIiB,cAAA;EAAA,MAAA,EACP,MAAA,CAAK,MADgB;EAAA,OAAA,EAEpB,OAFoB;KACrB,EAAA,MAAK;UACJ,EAEC,eAFD;aAEC,EACG,aADH;qBACG,EACQ,qBADR;cACQ,EACP,cADO;eACP,EACC,eADD;mBACC,EACI,mBADJ;;;AA+rCjB;;;;;UAAiB,eAAA;UACP;UACA;cACI;;iBAMQ,YAAA,WACV,qBACA,4BACD;;WAA+B;sBACtB,kBACjB,QAAQ"}
+{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;UAgJiB,cAAA;EAAA,MAAA,EACP,MAAA,CAAK,MADgB;EAAA,OAAA,EAEpB,OAFoB;KACrB,EAAA,MAAK;UACJ,EAEC,eAFD;aAEC,EACG,aADH;qBACG,EACQ,qBADR;cACQ,EACP,cADO;eACP,EACC,eADD;mBACC,EACI,mBADJ;;;AAqkDjB;;;;;UAAiB,eAAA;UACP;UACA;cACI;;iBAMQ,YAAA,WACV,qBACA,4BACD;;WAA+B;sBACtB,kBACjB,QAAQ"}

package/dist/server.js

@@ -1,13 +1,14 @@
+import { DEFAULT_TEST_ID } from "./constants.js";
 import { markAuthenticatedRequest, resolveInboundAuth, validateRequestApiKey, writeApiKeyHttpRejection, writeApiKeyUpgradeRejection } from "./api-key-auth.js";
-import { buildContentWithToolCallsChunks, buildContentWithToolCallsCompletion, buildTextChunks, buildTextCompletion, buildToolCallChunks, buildToolCallCompletion, buildUsageChunk, extractOverrides, flattenHeaders, getContext, getTestId, isAudioResponse, isContentWithToolCallsResponse, isErrorResponse, isTextResponse, isToolCallResponse, readBody, resolveFixtureBlocks, resolveReasoningForModel, resolveResponse, resolveStrictMode, resolveUsage, serializeErrorResponse, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField } from "./helpers.js";
+import { buildContentWithToolCallsChunks, buildContentWithToolCallsCompletion, buildTextChunks, buildTextCompletion, buildToolCallChunks, buildToolCallCompletion, buildUsageChunk, extractOverrides, flattenHeaders, getContext, getTestId, isAudioResponse, isContentWithToolCallsResponse, isEmbeddingResponse, isErrorResponse, isImageResponse, isJSONResponse, isJsonObject, isResponseFactory, isTextResponse, isToolCallResponse, isTranscriptionResponse, isVideoResponse, readBody, resolveFixtureBlocks, resolveReasoningForModel, resolveResponse, resolveStrictMode, resolveUsage, serializeErrorResponse, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField } from "./helpers.js";
 import { Logger } from "./logger.js";
 import { Journal } from "./journal.js";
 import { matchFixtureDiagnostic, recordMatchOptions } from "./router.js";
-import { entryToFixture, validateFixtures } from "./fixture-loader.js";
+import { INJECTED_STATUS_RANGE, entryToFixture, isInjectableStatus, validateFixtures } from "./fixture-loader.js";
 import { writeErrorResponse, writeSSEStream } from "./sse-writer.js";
 import { createInterruptionSignal } from "./interruption.js";
 import { buildOpenRouterCandidates, handleOpenRouterCredits, handleOpenRouterKey, handleOpenRouterModels, isOpenRouterPath, resolveOpenRouterShaping, serializeOpenRouterError, shapeOpenRouterChunks, shapeOpenRouterCompletion } from "./openrouter-chat.js";
-import { applyChaosAction, evaluateChaos } from "./chaos.js";
+import { applyChaosAction, evaluateChaos, isChaosScope } from "./chaos.js";
 import { proxyAndRecord } from "./recorder.js";
 import { handleResponses } from "./responses.js";
 import { handleMessages } from "./messages.js";
@@ -125,7 +126,8 @@ const DEFAULT_MODELS = [
 const CORS_HEADERS = {
 	"Access-Control-Allow-Origin": "*",
 	"Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
-	"Access-Control-Allow-Headers": "*"
+	"Access-Control-Allow-Headers": "*",
+	"Access-Control-Expose-Headers": "X-Total-Count"
 };
 function setCorsHeaders(res) {
 	for (const [key, value] of Object.entries(CORS_HEADERS)) res.setHeader(key, value);
@@ -143,11 +145,24 @@ function handleNotFound(res, message) {
 	} }));
 }
 const CONTROL_PREFIX = "/__aimock";
+/** The complete `GET /__aimock/fixtures` query-param vocabulary; anything else 400s. */
+const FIXTURES_PARAMS = new Set(["include"]);
+/** The complete `GET /__aimock/journal` query-param vocabulary; anything else 400s. */
+const JOURNAL_PARAMS = new Set([
+	"limit",
+	"offset",
+	"path",
+	"method",
+	"status",
+	"service",
+	"testId"
+]);
 /**
 * Perform a full reset: clear the fixtures array, the journal (entries *and*
 * per-test fixture match-counts, i.e. sequence position), the video and fal.ai
-* job/queue state, and the Gemini interaction/event-id counters, then re-zero
-* the `aimock_fixtures_loaded` gauge.
+* job/queue state, the Gemini interaction/event-id counters, and any runtime
+* chaos override (reverting to the construction-time chaos config), then
+* re-zero the `aimock_fixtures_loaded` gauge.
 *
 * `targets` is `null` when no server is running (an in-process `reset()` before
 * `start()`). The process-global generation state is reset either way, since it
@@ -164,6 +179,7 @@ function performFullReset(fixtures, targets) {
 	resetEventIdCounter();
 	if (!targets) return;
 	targets.journal.clear();
+	targets.defaults.chaos = void 0;
 	targets.videoStates.clear();
 	targets.openRouterVideoJobs.clear();
 	targets.veoVideoJobs.clear();
@@ -172,10 +188,103 @@ function performFullReset(fixtures, targets) {
 	if (targets.defaults.registry) targets.defaults.registry.setGauge("aimock_fixtures_loaded", {}, fixtures.length);
 }
 /**
+* JSON-safe redaction for control-API inspection output. Functions (fixture
+* `predicate`s, response factories) and RegExps do not survive
+* JSON.stringify as anything useful, so they become marker strings.
+*/
+function redactForInspection(value) {
+	if (typeof value === "function") return "[function]";
+	if (value instanceof RegExp) return String(value);
+	if (Array.isArray(value)) return value.map(redactForInspection);
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [key, entry] of Object.entries(value)) out[key] = redactForInspection(entry);
+		return out;
+	}
+	return value;
+}
+/**
+* One-line kind label for a fixture response used by
+* `GET /__aimock/fixtures?include=fixtures` (e.g. "text", "error").
+* Response factories are reported as "factory".
+*
+* Discriminates with the same `is*Response` guards the request handlers use,
+* in the same order — NOT by inspecting keys. Every response shape extends
+* `ResponseOverrides` (`id`/`created`/`model`/`usage`), so a recorded fixture's
+* first key is usually an envelope override rather than the discriminant. The
+* audio-before-content/toolCalls order is the ORDERING CONTRACT documented on
+* `AudioResponse` in types.ts: those shapes structurally overlap.
+*/
+function fixtureResponseKind(response) {
+	if (isResponseFactory(response)) return "factory";
+	if (isErrorResponse(response)) return "error";
+	if (isAudioResponse(response)) return "audio";
+	if (isVideoResponse(response)) return "video";
+	if (isTranscriptionResponse(response)) return "transcription";
+	if (isImageResponse(response)) return "image";
+	if (isEmbeddingResponse(response)) return "embedding";
+	if (isJSONResponse(response)) return "json";
+	if (isContentWithToolCallsResponse(response)) return "contentWithToolCalls";
+	if (isToolCallResponse(response)) return "toolCalls";
+	if (isTextResponse(response)) return "text";
+	return "unknown";
+}
+/**
+* Resolve a journal entry's testId exactly the way `getTestId` resolves an
+* incoming request's: the `X-Test-Id` header wins, then `?testId=` parsed out
+* of the query string, then `DEFAULT_TEST_ID`. The
+* filter and the server's own per-test isolation must never disagree — and a
+* raw `path.includes("testId=t1")` both prefix-collides with `t10` and matches
+* unrelated params like `notTestId`.
+*/
+function journalEntryTestId(entry) {
+	const header = entry.headers["x-test-id"];
+	if (header) return header;
+	const qIdx = entry.path.indexOf("?");
+	if (qIdx !== -1) {
+		const queryValue = new URLSearchParams(entry.path.slice(qIdx + 1)).get("testId");
+		if (queryValue) return queryValue;
+	}
+	return DEFAULT_TEST_ID;
+}
+/**
+* The testId a chaos override is stored under, and read back with — resolved by
+* `getTestId`, i.e. `X-Test-Id` header then `?testId=`, exactly as
+* `resolveScopedDefaults` resolves the traffic being evaluated. A control call
+* and the requests it is meant to affect can then never land in different
+* scopes. `DEFAULT_TEST_ID` (neither header nor param) means the server-wide
+* baseline.
+*
+* Returns `null` when `X-Test-Id` is PRESENT but blank. `String(testId ?? "")`
+* in a harness produces that trivially, and silently treating it as "untagged"
+* would install a server-wide baseline that fails every other test — the exact
+* cross-test leak per-testId scoping exists to prevent. Callers must 400.
+*/
+function chaosScopeId(req) {
+	const headerValue = req.headers["x-test-id"];
+	const raw = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+	if (typeof raw === "string" && raw.trim() === "") return null;
+	return getTestId(req);
+}
+/** 400 for a control call whose `X-Test-Id` is present but blank. */
+function writeBlankTestId(res) {
+	res.writeHead(400, { "Content-Type": "application/json" });
+	res.end(JSON.stringify({ error: "Invalid 'X-Test-Id': header is present but empty" }));
+	return true;
+}
+/** The chaos config in effect for one testId: its override, else the baseline. */
+function effectiveChaos(defaults, scopeId) {
+	const scoped = defaults.chaosByTestId?.get(scopeId);
+	if (scoped) return scoped;
+	const current = defaults.chaos;
+	if (!current) return {};
+	return isChaosScope(current) ? current.base ?? {} : current;
+}
+/**
 * Handle requests under `/__aimock/`. Returns `true` if the request was
 * handled, `false` if the path doesn't match the control prefix.
 */
-async function handleControlAPI(req, res, pathname, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults) {
+async function handleControlAPI(req, res, pathname, searchParams, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults) {
 	if (!pathname.startsWith(CONTROL_PREFIX)) return false;
 	const subPath = pathname.slice(9);
 	setCorsHeaders(res);
@@ -185,13 +294,148 @@ async function handleControlAPI(req, res, pathname, fixtures, journal, videoStat
 		return true;
 	}
 	if (subPath === "/journal" && req.method === "GET") {
-		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify(journal.getAll()));
+		const bad = (message) => {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: message }));
+			return true;
+		};
+		for (const key of searchParams.keys()) if (!JOURNAL_PARAMS.has(key)) return bad(`Unknown query parameter: '${key}'. Supported: ${[...JOURNAL_PARAMS].join(", ")}`);
+		const parseNonNegativeInt = (name, fallback) => {
+			const raw = searchParams.get(name);
+			if (raw === null) return fallback;
+			if (!/^\d+$/.test(raw.trim())) return null;
+			return Number(raw);
+		};
+		const limit = parseNonNegativeInt("limit", -1);
+		const offset = parseNonNegativeInt("offset", 0);
+		if (limit === null) return bad("Invalid 'limit': must be an integer >= 0");
+		if (offset === null) return bad("Invalid 'offset': must be an integer >= 0");
+		let statusFilter;
+		const statusRaw = searchParams.get("status");
+		if (statusRaw !== null) {
+			if (!/^\d+$/.test(statusRaw.trim())) return bad("Invalid 'status': must be an integer");
+			statusFilter = Number(statusRaw);
+		}
+		const pathFilter = searchParams.get("path");
+		const methodFilter = searchParams.get("method");
+		const serviceFilter = searchParams.get("service");
+		const testIdFilter = searchParams.get("testId");
+		let entries = journal.getAll();
+		if (methodFilter !== null) {
+			const want = methodFilter.toUpperCase();
+			entries = entries.filter((e) => e.method.toUpperCase() === want);
+		}
+		if (pathFilter !== null) entries = entries.filter((e) => e.path.includes(pathFilter));
+		if (statusFilter !== void 0) entries = entries.filter((e) => e.response.status === statusFilter);
+		if (serviceFilter !== null) entries = entries.filter((e) => e.service === serviceFilter);
+		if (testIdFilter !== null) entries = entries.filter((e) => journalEntryTestId(e) === testIdFilter);
+		const total = entries.length;
+		if (offset > 0) entries = entries.slice(offset);
+		if (limit >= 0) entries = entries.slice(0, limit);
+		res.writeHead(200, {
+			"Content-Type": "application/json",
+			"X-Total-Count": String(total)
+		});
+		res.end(JSON.stringify(entries));
 		return true;
 	}
 	if (subPath === "/fixtures" && req.method === "GET") {
+		for (const key of searchParams.keys()) if (!FIXTURES_PARAMS.has(key)) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Unknown query parameter: '${key}'. Supported: ${[...FIXTURES_PARAMS].join(", ")}` }));
+			return true;
+		}
+		const include = searchParams.get("include");
+		if (include === null) {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ count: fixtures.length }));
+			return true;
+		}
+		if (include !== "fixtures") {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Invalid 'include': expected 'fixtures'" }));
+			return true;
+		}
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			count: fixtures.length,
+			fixtures: fixtures.map((fixture, index) => ({
+				index,
+				match: redactForInspection(fixture.match),
+				responseKind: fixtureResponseKind(fixture.response),
+				...fixture.latency !== void 0 ? { latency: fixture.latency } : {},
+				...fixture.chaos !== void 0 ? { chaos: fixture.chaos } : {}
+			}))
+		}));
+		return true;
+	}
+	if (subPath === "/chaos" && req.method === "GET") {
+		const scopeId = chaosScopeId(req);
+		if (scopeId === null) return writeBlankTestId(res);
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ chaos: effectiveChaos(defaults, scopeId) }));
+		return true;
+	}
+	if (subPath === "/chaos" && req.method === "DELETE") {
+		const scopeId = chaosScopeId(req);
+		if (scopeId === null) return writeBlankTestId(res);
+		defaults.chaosByTestId?.delete(scopeId);
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ chaos: effectiveChaos(defaults, scopeId) }));
+		return true;
+	}
+	if (subPath === "/chaos" && req.method === "POST") {
+		const scopeId = chaosScopeId(req);
+		if (scopeId === null) return writeBlankTestId(res);
+		let raw;
+		try {
+			raw = await readBody(req);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			defaults.logger.error(`POST /__aimock/chaos: failed to read body: ${msg}`);
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Failed to read request body: ${msg}` }));
+			return true;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			defaults.logger.error(`POST /__aimock/chaos: invalid JSON: ${msg}`);
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Invalid JSON: ${msg}` }));
+			return true;
+		}
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Invalid body: expected a JSON object" }));
+			return true;
+		}
+		const allowed = [
+			"dropRate",
+			"malformedRate",
+			"disconnectRate"
+		];
+		for (const key of Object.keys(parsed)) if (!allowed.includes(key)) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Unknown chaos field: '${key}'` }));
+			return true;
+		}
+		const next = {};
+		for (const key of allowed) {
+			const value = parsed[key];
+			if (value === void 0) continue;
+			if (typeof value !== "number" || Number.isNaN(value) || value < 0 || value > 1) {
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: `Invalid '${key}': must be a number between 0 and 1` }));
+				return true;
+			}
+			next[key] = value;
+		}
+		defaults.chaosByTestId?.set(scopeId, next);
 		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ count: fixtures.length }));
+		res.end(JSON.stringify({ chaos: effectiveChaos(defaults, scopeId) }));
 		return true;
 	}
 	if (subPath === "/fixtures" && req.method === "POST") {
@@ -300,8 +544,37 @@ async function handleControlAPI(req, res, pathname, fixtures, journal, videoStat
 			res.end(JSON.stringify({ error: `Invalid JSON: ${msg}` }));
 			return true;
 		}
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Invalid body: expected a JSON object" }));
+			return true;
+		}
 		const status = parsed.status ?? 500;
+		if (!isInjectableStatus(status)) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Invalid 'status': must be ${INJECTED_STATUS_RANGE}` }));
+			return true;
+		}
 		const errorBody = parsed.body;
+		if (errorBody !== void 0 && errorBody !== null) {
+			if (typeof errorBody !== "object" || Array.isArray(errorBody)) {
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: "Invalid 'body': must be an object" }));
+				return true;
+			}
+			for (const field of [
+				"message",
+				"type",
+				"code"
+			]) {
+				const value = errorBody[field];
+				if (value !== void 0 && value !== null && typeof value !== "string") {
+					res.writeHead(400, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({ error: `Invalid 'body.${field}': must be a string` }));
+					return true;
+				}
+			}
+		}
 		const errorFixture = {
 			match: { predicate: () => true },
 			response: {
@@ -361,7 +634,6 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 	let body;
 	try {
 		body = JSON.parse(raw);
-		if (modelFallback && !body.model) body.model = modelFallback;
 	} catch (parseErr) {
 		const detail = parseErr instanceof Error ? parseErr.message : "unknown parse error";
 		journal.add({
@@ -382,6 +654,24 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		} }));
 		return;
 	}
+	if (!isJsonObject(body)) {
+		journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? COMPLETIONS_PATH,
+			headers: flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 400,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, 400, openRouter ? serializeOpenRouterError(400, "Request body must be a JSON object") : JSON.stringify({ error: {
+			message: "Request body must be a JSON object",
+			type: "invalid_request_error"
+		} }));
+		return;
+	}
+	if (modelFallback && !body.model) body.model = modelFallback;
 	if (!Array.isArray(body.messages)) {
 		journal.add({
 			method: req.method ?? "POST",
@@ -473,7 +763,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		const snippet = typeof lastUserMsg?.content === "string" ? lastUserMsg.content.slice(0, 80) : "";
 		defaults.logger.debug(`No fixture matched for request (model=${body.model ?? "?"}, msg="${snippet}")`);
 	}
-	const chaosAction = evaluateChaos(fixture, defaults.chaos, req.headers, defaults.logger);
+	const chaosAction = evaluateChaos(fixture, defaults.chaos, req.headers, defaults.logger, req.url);
 	const chaosContext = {
 		method,
 		path,
@@ -770,13 +1060,27 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 	const logger = new Logger(options?.logLevel ?? "silent");
 	const registry = options?.metrics ? createMetricsRegistry() : void 0;
 	const serverOptions = options ?? {};
+	const chaosByTestId = /* @__PURE__ */ new Map();
 	const defaults = {
 		latency: serverOptions.latency ?? 0,
 		chunkSize: Math.max(1, serverOptions.chunkSize ?? DEFAULT_CHUNK_SIZE),
 		replaySpeed: serverOptions.replaySpeed ?? 1,
 		logger,
+		chaosByTestId,
 		get chaos() {
-			return serverOptions.chaos;
+			return {
+				base: chaosByTestId.get(DEFAULT_TEST_ID) ?? serverOptions.chaos,
+				byTestId: chaosByTestId
+			};
+		},
+		set chaos(value) {
+			if (value === void 0) {
+				chaosByTestId.clear();
+				return;
+			}
+			const base = isChaosScope(value) ? value.base : value;
+			if (base === void 0) chaosByTestId.delete(DEFAULT_TEST_ID);
+			else chaosByTestId.set(DEFAULT_TEST_ID, base);
 		},
 		registry,
 		get record() {
@@ -933,7 +1237,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			markAuthenticatedRequest(req, resolvedAuth.policy);
 		}
 		if (pathname.startsWith(CONTROL_PREFIX)) {
-			await handleControlAPI(req, res, pathname, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults);
+			await handleControlAPI(req, res, pathname, parsedUrl.searchParams, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults);
 			return;
 		}
 		if (mounts) {
@@ -1825,7 +2129,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			try {
 				falBody = req.method === "POST" || req.method === "PUT" ? await readBody(req) : "";
 				const raw = falBody;
-				const chaosAction = evaluateChaos(null, defaults.chaos, req.headers, defaults.logger);
+				const chaosAction = evaluateChaos(null, defaults.chaos, req.headers, defaults.logger, req.url);
 				if (chaosAction) {
 					applyChaosAction(chaosAction, res, null, journal, {
 						method: req.method ?? "GET",
@@ -1867,7 +2171,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			setCorsHeaders(res);
 			try {
 				const raw = req.method === "POST" || req.method === "PUT" ? falBody ?? await readBody(req) : "{}";
-				const chaosAction = evaluateChaos(null, defaults.chaos, req.headers, defaults.logger);
+				const chaosAction = evaluateChaos(null, defaults.chaos, req.headers, defaults.logger, req.url);
 				if (chaosAction) {
 					applyChaosAction(chaosAction, res, null, journal, {
 						method: req.method ?? "GET",