@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/server.cjs

@@ -1,10 +1,12 @@
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_constants = require('./constants.cjs');
+const require_message_text = require('./message-text.cjs');
 const require_api_key_auth = require('./api-key-auth.cjs');
 const require_helpers = require('./helpers.cjs');
 const require_live_fixture = require('./live-fixture.cjs');
 const require_sse_writer = require('./sse-writer.cjs');
 const require_chaos = require('./chaos.cjs');
+const require_misbehavior = require('./misbehavior.cjs');
 const require_fixture_loader = require('./fixture-loader.cjs');
 const require_router = require('./router.cjs');
 const require_recorder = require('./recorder.cjs');
@@ -38,6 +40,7 @@ const require_search = require('./search.cjs');
 const require_rerank = require('./rerank.cjs');
 const require_moderation = require('./moderation.cjs');
 const require_fine_tuning = require('./fine-tuning.cjs');
+const require_vector_stores = require('./vector-stores.cjs');
 const require_files = require('./files.cjs');
 const require_batches = require('./batches.cjs');
 const require_ws_framing = require('./ws-framing.cjs');
@@ -45,42 +48,19 @@ const require_ws_live = require('./ws-live.cjs');
 const require_ws_responses = require('./ws-responses.cjs');
 const require_ws_realtime = require('./ws-realtime.cjs');
 const require_ws_gemini_live = require('./ws-gemini-live.cjs');
+const require_route_registry = require('./route-registry.cjs');
+const require_openapi = require('./openapi.cjs');
 const require_metrics = require('./metrics.cjs');
+const require_mcp_fakes = require('./mcp-fakes.cjs');
+const require_mcp_mock = require('./mcp-mock.cjs');
+const require_mcp_fakes_mount = require('./mcp-fakes-mount.cjs');
+const require_mcp_fakes_report = require('./mcp-fakes-report.cjs');
 let node_http = require("node:http");
 node_http = require_runtime.__toESM(node_http);
 let node_async_hooks = require("node:async_hooks");
 
 //#region src/server.ts
 const liveClosers = /* @__PURE__ */ new WeakMap();
-const COMPLETIONS_PATH = "/v1/chat/completions";
-const RESPONSES_PATH = "/v1/responses";
-const LIVE_PATH = "/v1/live/sessions";
-const REALTIME_PATH = "/v1/realtime";
-const GEMINI_LIVE_PATH = "/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
-const MESSAGES_PATH = "/v1/messages";
-const EMBEDDINGS_PATH = "/v1/embeddings";
-const COHERE_CHAT_PATH = "/v2/chat";
-const COHERE_EMBED_PATH = "/v2/embed";
-const SEARCH_PATH = "/search";
-const RERANK_PATH = "/v2/rerank";
-const MODERATIONS_PATH = "/v1/moderations";
-const IMAGES_PATH = "/v1/images/generations";
-const IMAGES_EDIT_PATH = "/v1/images/edits";
-const IMAGES_VARIATIONS_PATH = "/v1/images/variations";
-const SPEECH_PATH = "/v1/audio/speech";
-const TRANSCRIPTIONS_PATH = "/v1/audio/transcriptions";
-const TRANSLATIONS_PATH = "/v1/audio/translations";
-const VIDEOS_PATH = "/v1/videos";
-const GEMINI_PREDICT_RE = /^\/v1beta\/models\/([^:]+):predict$/;
-const ELEVENLABS_SOUND_GENERATION_PATH = "/v1/sound-generation";
-const ELEVENLABS_TTS_RE = /^\/v1\/text-to-speech\/([^/]+)$/;
-const ELEVENLABS_MUSIC_RE = /^\/v1\/music(?:\/(.+))?$/;
-const ELEVENLABS_VOICE_DESIGN_PATH = "/v1/text-to-voice/design";
-const ELEVENLABS_VOICE_CREATE_PATH = "/v1/text-to-voice";
-const ELEVENLABS_VOICE_RE = /^\/v1\/voices\/([^/]+)$/;
-const FAL_QUEUE_SUBMIT_RE = /^\/fal\/queue\/submit\/(.+)$/;
-const FAL_QUEUE_REQUESTS_RE = /^\/fal\/queue\/requests\/(.+)$/;
-const FAL_RUN_RE = /^\/fal\/run\/(.+)$/;
 const DEFAULT_CHUNK_SIZE = 20;
 const COMPAT_SUFFIXES = [
 	"/chat/completions",
@@ -109,34 +89,6 @@ function normalizeCompatPath(pathname, logger) {
 	}
 	return pathname;
 }
-const GEMINI_INTERACTIONS_PATH = "/v1beta/interactions";
-const GEMINI_PATH_RE = /^\/v1beta\/models\/([^:]+):(generateContent|streamGenerateContent)$/;
-const GEMINI_EMBED_RE = /^\/v1beta\/models\/([^:]+):embedContent$/;
-const AZURE_DEPLOYMENT_RE = /^\/openai\/deployments\/([^/]+)\/(chat\/completions|embeddings)$/;
-const BEDROCK_INVOKE_RE = /^\/model\/([^/]+)\/invoke$/;
-const BEDROCK_STREAM_RE = /^\/model\/([^/]+)\/invoke-with-response-stream$/;
-const BEDROCK_CONVERSE_RE = /^\/model\/([^/]+)\/converse$/;
-const BEDROCK_CONVERSE_STREAM_RE = /^\/model\/([^/]+)\/converse-stream$/;
-const VERTEX_AI_RE = /^\/v1\/projects\/[^/]+\/locations\/[^/]+\/publishers\/google\/models\/([^/:]+):(generateContent|streamGenerateContent)$/;
-const OLLAMA_CHAT_PATH = "/api/chat";
-const OLLAMA_GENERATE_PATH = "/api/generate";
-const OLLAMA_EMBEDDINGS_PATH = "/api/embeddings";
-const OLLAMA_EMBED_PATH = "/api/embed";
-const OLLAMA_TAGS_PATH = "/api/tags";
-const OPENROUTER_VIDEOS_PATH = "/api/v1/videos";
-const OPENROUTER_VIDEO_MODELS_PATH = "/api/v1/videos/models";
-const HEALTH_PATH = "/health";
-const READY_PATH = "/ready";
-const MODELS_PATH = "/v1/models";
-const REQUESTS_PATH = "/v1/_requests";
-const BATCHES_PATH = "/v1/batches";
-const BATCHES_ID_RE = /^\/v1\/batches\/([^/]+)$/;
-const BATCHES_CANCEL_RE = /^\/v1\/batches\/([^/]+)\/cancel$/;
-const FILES_PATH = "/v1/files";
-const FINE_TUNING_JOBS_PATH = "/v1/fine_tuning/jobs";
-const FINE_TUNING_ID_RE = /^\/v1\/fine_tuning\/jobs\/([^/]+)$/;
-const FINE_TUNING_CANCEL_RE = /^\/v1\/fine_tuning\/jobs\/([^/]+)\/cancel$/;
-const FINE_TUNING_EVENTS_RE = /^\/v1\/fine_tuning\/jobs\/([^/]+)\/events$/;
 const DEFAULT_MODELS = [
 	"gpt-4",
 	"gpt-4o",
@@ -146,7 +98,7 @@ const DEFAULT_MODELS = [
 ];
 const CORS_HEADERS = {
 	"Access-Control-Allow-Origin": "*",
-	"Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+	"Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
 	"Access-Control-Allow-Headers": "*",
 	"Access-Control-Expose-Headers": "X-Total-Count, X-Request-Id"
 };
@@ -165,7 +117,6 @@ function handleNotFound(res, message) {
 		type: "not_found"
 	} }));
 }
-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. */
@@ -204,6 +155,7 @@ function performFullReset(fixtures, targets) {
 	require_elevenlabs_voice.clearElevenLabsVoices();
 	require_files.clearFileStore();
 	require_fine_tuning.clearFineTuningStore();
+	require_vector_stores.clearVectorStoreStore();
 	require_gemini_interactions.resetInteractionCounter();
 	require_gemini_interactions.resetEventIdCounter();
 	if (!targets) return;
@@ -211,11 +163,13 @@ function performFullReset(fixtures, targets) {
 	targets.journal.clear();
 	require_chaos.resetChaosWarnings(targets.defaults.logger);
 	targets.defaults.chaos = void 0;
+	targets.defaults.misbehavior?.byTestId.clear();
 	targets.videoStates.clear();
 	targets.openRouterVideoJobs.clear();
 	targets.veoVideoJobs.clear();
 	targets.grokVideoJobs.clear();
 	targets.bytePlusVideoJobs.clear();
+	for (const { handler } of targets.mounts ?? []) handler.clearMcpFakes?.();
 	if (targets.defaults.registry) targets.defaults.registry.setGauge("aimock_fixtures_loaded", {}, fixtures.length);
 }
 /**
@@ -255,7 +209,7 @@ function fixtureResponseKind(response) {
 	if (require_helpers.isImageResponse(response)) return "image";
 	if (require_helpers.isEmbeddingResponse(response)) return "embedding";
 	if (require_helpers.isJSONResponse(response)) return "json";
-	if (require_helpers.isContentWithToolCallsResponse(response)) return "contentWithToolCalls";
+	if (require_helpers.isCombinedFixtureResponse(response)) return "contentWithToolCalls";
 	if (require_helpers.isToolCallResponse(response)) return "toolCalls";
 	if (require_helpers.isTextResponse(response)) return "text";
 	return "unknown";
@@ -270,9 +224,14 @@ function fixtureResponseKind(response) {
 * scoping path does not also do. (Splitting on "," additionally broke every
 * legitimately comma-bearing id.) A raw `path.includes("testId=t1")` both
 * prefix-collides with `t10` and matches unrelated params like `notTestId`.
+*
+* An MCP mount records the test id it resolved on the entry (I9, B3): a
+* decoded header or query value, or the one bound to the session at
+* `initialize`. That value wins; LLM entries carry none and are attributed as
+* before.
 */
 function journalEntryTestId(entry) {
-	return require_helpers.resolveTestId(entry.headers, entry.path);
+	return entry.testId ?? require_helpers.resolveTestId(entry.headers, entry.path);
 }
 /**
 * The testId a chaos override is stored under, and read back with — resolved by
@@ -311,19 +270,188 @@ function effectiveChaos(defaults, scopeId) {
 	if (!current) return {};
 	return require_chaos.isChaosScope(current) ? current.base ?? {} : current;
 }
+/** The `GET /__aimock/mcp/fakes` query-param vocabulary; anything else 400s. */
+const MCP_FAKES_PARAMS = new Set([
+	"testId",
+	"context",
+	"mount"
+]);
+/** A block's `mount` path, read without running getters; the add validates it. */
+function controlFakeMountOf(raw) {
+	if (typeof raw !== "object" || raw === null) return require_mcp_fakes.MCP_FAKES_DEFAULT_MOUNT;
+	const value = Object.getOwnPropertyDescriptor(raw, "mount")?.value;
+	return typeof value === "string" ? value : require_mcp_fakes.MCP_FAKES_DEFAULT_MOUNT;
+}
+/**
+* Check one `POST /__aimock/fixtures` `mcpFakes` value against the live
+* mounts (F10, W6) without changing anything. Returns every error in input
+* order (an empty list when the value can be added), and `apply`, which adds
+* the blocks (auto-mounting an MCPMock where no mount serves a block's path)
+* and returns the number of blocks added.
+*
+* The whole value is checked before any mount is touched, and the check
+* never adds to a real mount: each group is added to a throwaway store,
+* whose errors are the ones reported (it numbers the add `control-api#1`, as
+* a new mount would; for an existing MCPMock the rejected group is re-run on
+* its atomic add, so the errors name that mount's next `<n>`, I7). A group
+* whose path no request to it can reach (a mount that is not an MCPMock
+* serves it, an MCPMock answers it as its root, or it is under the control
+* prefix) is a mount conflict (one error per block).
+*/
+function planControlApiFakes(raw, mounts) {
+	const items = Array.isArray(raw) ? raw.map((block, position) => ({
+		position,
+		source: {
+			source: "control-api",
+			blockIndex: position,
+			raw: block
+		}
+	})) : [{
+		position: 0,
+		source: {
+			source: "control-api",
+			blockIndex: null,
+			raw
+		}
+	}];
+	const groups = /* @__PURE__ */ new Map();
+	if (items.length === 0) groups.set(require_mcp_fakes.MCP_FAKES_DEFAULT_MOUNT, {
+		path: require_mcp_fakes.MCP_FAKES_DEFAULT_MOUNT,
+		positions: [],
+		sources: []
+	});
+	for (const { position, source } of items) {
+		const path = controlFakeMountOf(source.raw);
+		const group = groups.get(path) ?? {
+			path,
+			positions: [],
+			sources: []
+		};
+		group.positions.push(position);
+		group.sources.push(source);
+		groups.set(path, group);
+	}
+	const found = [];
+	/** The paths `apply` auto-mounts, in order. */
+	const pending = [];
+	for (const group of groups.values()) {
+		const target = require_mcp_fakes_mount.findFakeMount(mounts, group.path, pending);
+		if (target.kind === "conflict") {
+			group.positions.forEach((position) => {
+				const where = Array.isArray(raw) ? require_message_text.msg`mcpFakes[${position}]` : require_message_text.msg`mcpFakes`;
+				found.push({
+					position,
+					error: new require_fixture_loader.FixtureLoadError({
+						rule: "mcp-fakes/mount-conflict",
+						file: null,
+						blockId: null,
+						entryId: null,
+						detail: require_message_text.msg`${where}: ${require_mcp_fakes_mount.mountConflictDetail(group.path, target)}`
+					})
+				});
+			});
+			continue;
+		}
+		let failure = addFailure(() => new require_mcp_fakes.McpFakeStore().add(group.sources, { kind: "control-api" }));
+		if (target.kind === "none") pending.push(group.path);
+		if (!failure) continue;
+		if (target.kind === "mcp" && target.handler.addMcpFakes === require_mcp_mock.MCPMock.prototype.addMcpFakes) {
+			const handler = target.handler;
+			failure = addFailure(() => handler.addMcpFakes?.(group.sources, { kind: "control-api" })) ?? failure;
+		}
+		for (const error of failure.errors) found.push({
+			position: positionOf(error, group),
+			error
+		});
+	}
+	found.sort((a, b) => a.position - b.position);
+	return {
+		errors: found.map((f) => f.error),
+		apply(wiring) {
+			let added = 0;
+			for (const group of groups.values()) {
+				const target = require_mcp_fakes_mount.ensureFakeMount(mounts, group.path, {
+					journal: wiring.journal,
+					registry: wiring.defaults.registry,
+					logger: wiring.defaults.logger,
+					replaySpeed: wiring.defaults.replaySpeed
+				}, wiring.defaults.logger);
+				if ("conflict" in target) continue;
+				const result = target.handler.addMcpFakes?.(group.sources, { kind: "control-api" });
+				for (const warning of result?.warnings ?? []) wiring.defaults.logger.warn(warning.message);
+				added += group.sources.length;
+			}
+			return added;
+		}
+	};
+}
+/** The `McpFakesAddError` that `add` throws, or `null` when it adds. */
+function addFailure(add) {
+	try {
+		add();
+		return null;
+	} catch (err) {
+		if (err instanceof require_mcp_fakes.McpFakesAddError) return err;
+		throw err;
+	}
+}
+/**
+* The request position of the block an add error names. The add numbers a
+* run-time group's blocks by their place in the group (`[<j>]`), or gives no
+* index to a single-object value; an error tied to no block sorts with the
+* group's first block.
+*/
+function positionOf(error, group) {
+	const first = group.positions[0] ?? 0;
+	if (error.blockId == null || error.file === null) return first;
+	const at = group.positions.findIndex((_, j) => error.blockId === require_mcp_fakes.blockIdOf(error.file ?? "", "", j));
+	return at === -1 ? first : group.positions[at];
+}
+function hasFakesSnapshot(handler) {
+	return "fakesSnapshot" in handler && typeof handler.fakesSnapshot === "function";
+}
+/**
+* `GET /__aimock/mcp/fakes` (spec 6.5, I9): for each MCP mount (or the one
+* named by `mount`), the blocks that apply to the requested test id and
+* context, with every entry id and its consumed state for that test id.
+* A mount is listed when it takes fakes (it implements `addMcpFakes`, the
+* check every other fakes path uses); one with no `fakesSnapshot` lists no
+* blocks.
+*/
+function listControlApiFakes(mounts, testId, context, mount) {
+	const listed = mounts.flatMap(({ path, handler }) => require_mcp_fakes_mount.isFakeMount(handler) && (mount === null || path === mount) ? [{
+		mount: path,
+		blocks: hasFakesSnapshot(handler) ? handler.fakesSnapshot(testId, context) : []
+	}] : []);
+	return mount !== null && listed.length === 0 ? null : listed;
+}
+const controlFixtureAdditions = /* @__PURE__ */ new WeakMap();
 /**
 * 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, searchParams, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults) {
-	if (!pathname.startsWith(CONTROL_PREFIX)) return false;
-	const subPath = pathname.slice(9);
+async function handleControlAPI(req, res, pathname, searchParams, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults, mounts) {
+	if (!pathname.startsWith(require_route_registry.CONTROL_PREFIX)) return false;
+	const subPath = pathname.slice(require_route_registry.CONTROL_PREFIX.length);
 	setCorsHeaders(res);
 	if (subPath === "/health" && req.method === "GET") {
 		res.writeHead(200, { "Content-Type": "application/json" });
 		res.end(JSON.stringify({ status: "ok" }));
 		return true;
 	}
+	if (subPath === "/openapi.json" && req.method === "GET") {
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(require_openapi.buildOpenApiDocument()));
+		return true;
+	}
+	if (subPath === "/routes" && req.method === "GET") {
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			count: require_openapi.CATALOG_ROUTES.length,
+			routes: require_openapi.CATALOG_ROUTES
+		}));
+		return true;
+	}
 	if (subPath === "/journal" && req.method === "GET") {
 		const bad = (message) => {
 			res.writeHead(400, { "Content-Type": "application/json" });
@@ -369,7 +497,7 @@ async function handleControlAPI(req, res, pathname, searchParams, fixtures, jour
 			"Content-Type": "application/json",
 			"X-Total-Count": String(total)
 		});
-		res.end(JSON.stringify(entries));
+		res.end(journalJson(entries, journal));
 		return true;
 	}
 	if (subPath === "/fixtures" && req.method === "GET") {
@@ -389,19 +517,70 @@ async function handleControlAPI(req, res, pathname, searchParams, fixtures, jour
 			res.end(JSON.stringify({ error: "Invalid 'include': expected 'fixtures'" }));
 			return true;
 		}
+		const extendedTools = require_helpers.isExtendedResponsesToolsList(fixtures);
 		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: require_fixture_loader.isOneShotError(fixture) ? "error" : fixtureResponseKind(fixture.response),
+				responseKind: require_fixture_loader.isOneShotError(fixture) ? "error" : fixtureResponseKind(extendedTools || typeof fixture.response === "function" ? fixture.response : require_helpers.withoutResponsesToolKeys(fixture.response)),
 				...fixture.latency !== void 0 ? { latency: fixture.latency } : {},
 				...fixture.chaos !== void 0 ? { chaos: fixture.chaos } : {}
 			}))
 		}));
 		return true;
 	}
+	if (subPath === "/misbehavior/catalog" && req.method === "GET") {
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			catalog: require_misbehavior.MISBEHAVIOR_CATALOG,
+			WIRE_SUPPORT: require_misbehavior.WIRE_SUPPORT
+		}));
+		return true;
+	}
+	if (subPath === "/misbehavior" && (req.method === "GET" || req.method === "POST" || req.method === "DELETE")) {
+		const scopeId = chaosScopeId(req);
+		if (scopeId === null) return writeBlankTestId(res);
+		const reply = (status, body) => {
+			res.writeHead(status, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(body));
+			return true;
+		};
+		const scope = defaults.misbehavior;
+		if (!scope && req.method !== "GET") return reply(409, { error: "misbehavior is not enabled: start aimock with enableMisbehavior: true (CLI: --misbehavior)" });
+		if (req.method === "POST") {
+			let raw;
+			try {
+				raw = await require_helpers.readBody(req);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				defaults.logger.error(`POST /__aimock/misbehavior: failed to read body: ${msg}`);
+				return reply(400, { error: `Failed to read request body: ${msg}` });
+			}
+			let input;
+			try {
+				input = JSON.parse(raw);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				defaults.logger.error(`POST /__aimock/misbehavior: invalid JSON: ${msg}`);
+				return reply(400, { error: `Invalid JSON: ${msg}` });
+			}
+			if (require_helpers.isJsonObject(input) && Object.keys(input).length === 0) input = { faults: [] };
+			const parsed = require_misbehavior.parseMisbehavior(input);
+			if (!parsed.ok) return reply(400, {
+				error: "Validation failed",
+				rule: parsed.issue.rule,
+				message: parsed.issue.message
+			});
+			const config = parsed.config.seed === "random" ? {
+				...parsed.config,
+				seed: require_misbehavior.resolveMisbehaviorSeed(parsed.config.seed, defaults.logger)
+			} : parsed.config;
+			scope?.byTestId.set(scopeId, config);
+		} else if (req.method === "DELETE") scope?.byTestId.delete(scopeId);
+		return reply(200, { misbehavior: scope?.byTestId.get(scopeId) ?? scope?.baseline ?? { faults: [] } });
+	}
 	if (subPath === "/chaos" && req.method === "GET") {
 		const scopeId = chaosScopeId(req);
 		if (scopeId === null) return writeBlankTestId(res);
@@ -474,6 +653,25 @@ async function handleControlAPI(req, res, pathname, searchParams, fixtures, jour
 		res.end(JSON.stringify({ chaos: effectiveChaos(defaults, scopeId) }));
 		return true;
 	}
+	if (subPath === "/mcp/fakes" && req.method === "GET") {
+		const reply = (status, body) => {
+			res.writeHead(status, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(body));
+			return true;
+		};
+		for (const key of searchParams.keys()) if (!MCP_FAKES_PARAMS.has(key)) return reply(400, { error: `Unknown query parameter: '${key}'. Supported: ${[...MCP_FAKES_PARAMS].join(", ")}` });
+		const testId = searchParams.get("testId") || null;
+		const context = searchParams.get("context") || null;
+		const mount = searchParams.get("mount") || null;
+		const listed = listControlApiFakes(mounts, testId, context, mount);
+		if (listed === null) return reply(404, { error: require_message_text.build(require_message_text.msg`No MCP mount at ${require_message_text.quote(mount ?? "")}`) });
+		return reply(200, {
+			testId,
+			context,
+			mounts: listed
+		});
+	}
+	if (subPath === "/mcp/fakes/report" && req.method === "GET") return require_mcp_fakes_report.handleFakesReportRoute(res, searchParams, mounts);
 	if (subPath === "/fixtures" && req.method === "POST") {
 		let raw;
 		try {
@@ -495,29 +693,82 @@ async function handleControlAPI(req, res, pathname, searchParams, fixtures, jour
 			res.end(JSON.stringify({ error: `Invalid JSON: ${msg}` }));
 			return true;
 		}
-		if (!Array.isArray(parsed.fixtures)) {
+		const withFakes = typeof parsed === "object" && parsed !== null && Object.hasOwn(parsed, "mcpFakes");
+		if (parsed === null || !Array.isArray(parsed.fixtures) && !(withFakes && parsed.fixtures === void 0)) {
 			res.writeHead(400, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ error: "Missing or invalid \"fixtures\" array" }));
 			return true;
 		}
-		const converted = parsed.fixtures.map((e) => require_fixture_loader.entryToFixture(e));
-		const errors = require_fixture_loader.validateFixtures(converted).filter((i) => i.severity === "error");
-		if (errors.length > 0) {
+		const entries = Array.isArray(parsed.fixtures) ? parsed.fixtures : [];
+		const missingMatchIndex = entries.findIndex((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.match == null);
+		if (missingMatchIndex !== -1) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Fixture at index ${missingMatchIndex} is missing match` }));
+			return true;
+		}
+		const invalidMatchIndex = entries.findIndex((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.match != null && (typeof entry.match !== "object" || Array.isArray(entry.match)));
+		if (invalidMatchIndex !== -1) {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: `Fixture at index ${invalidMatchIndex}: match must be an object` }));
+			return true;
+		}
+		const extendedResponsesTools = defaults.responsesTools === "extended";
+		const markInPlace = extendedResponsesTools && require_helpers.isServerOwnedFixtures(fixtures);
+		const addition = controlFixtureAdditions.get(defaults) ?? 0;
+		controlFixtureAdditions.set(defaults, addition + 1);
+		const converted = [];
+		const loadErrors = [];
+		for (const [index, entry] of entries.entries()) try {
+			const fixture = require_fixture_loader.entryToFixture(entry, void 0, void 0, {
+				file: `control-api#${addition}`,
+				index
+			});
+			if (defaults.misbehavior) require_fixture_loader.enableHeldFixtureMisbehavior(fixture);
+			if (markInPlace) require_fixture_loader.markFixtureResponsesToolsExtended(fixture);
+			converted.push(fixture);
+		} catch (error) {
+			if (!(error instanceof require_fixture_loader.FixtureLoadError || error instanceof require_fixture_loader.MisbehaviorConfigError)) throw error;
+			loadErrors.push(error);
+		}
+		const errors = (loadErrors.length === 0 ? require_fixture_loader.validateFixtures(extendedResponsesTools ? converted.map(require_fixture_loader.responsesToolsExtendedView) : converted) : []).filter((i) => i.severity === "error");
+		const fakes = withFakes ? planControlApiFakes(parsed.mcpFakes, mounts) : null;
+		const fakeErrors = fakes?.errors ?? [];
+		const validationFailed = (details) => {
 			res.writeHead(400, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({
 				error: "Validation failed",
-				details: errors
+				details
 			}));
 			return true;
+		};
+		if (loadErrors.length > 0 || errors.length > 0 || fakeErrors.length > 0) return validationFailed([
+			...loadErrors.map((e) => e.toJSON()),
+			...errors,
+			...fakeErrors.map((e) => e.toJSON())
+		]);
+		let mcpFakesAdded = 0;
+		if (fakes) try {
+			mcpFakesAdded = fakes.apply({
+				journal,
+				defaults
+			});
+		} catch (err) {
+			if (!(err instanceof require_mcp_fakes.McpFakesAddError)) throw err;
+			return validationFailed(err.errors.map((e) => e.toJSON()));
 		}
 		fixtures.push(...converted);
 		if (defaults.registry) defaults.registry.setGauge("aimock_fixtures_loaded", {}, fixtures.length);
 		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ added: converted.length }));
+		res.end(JSON.stringify(withFakes ? {
+			added: converted.length,
+			mcpFakesAdded
+		} : { added: converted.length }));
 		return true;
 	}
 	if (subPath === "/fixtures" && req.method === "DELETE") {
 		require_fixture_loader.clearFixtureQueue(fixtures);
+		journal.clearMisbehaviorCounters();
+		for (const { handler } of mounts) handler.clearMcpFakes?.();
 		if (defaults.registry) defaults.registry.setGauge("aimock_fixtures_loaded", {}, fixtures.length);
 		res.writeHead(200, { "Content-Type": "application/json" });
 		res.end(JSON.stringify({ cleared: true }));
@@ -530,7 +781,8 @@ async function handleControlAPI(req, res, pathname, searchParams, fixtures, jour
 		veoVideoJobs,
 		grokVideoJobs,
 		bytePlusVideoJobs,
-		defaults
+		defaults,
+		mounts
 	});
 	if (subPath === "/reset" && req.method === "POST") {
 		performFullReset(fixtures, resetTargets());
@@ -632,15 +884,16 @@ function clientAbortedMidBody(req, res, err) {
 	if (err instanceof require_helpers.RequestBodyTooLargeError) return false;
 	return res.destroyed && !req.complete;
 }
-async function handleCompletions(req, res, fixtures, journal, defaults, modelFallback, providerKey, openRouter = false) {
+async function handleCompletions(req, res, fixtures, journal, defaults, getRequestEntry, modelFallback, providerKey, openRouter = false, beforeFixtureSelection, bytePlusPath = false) {
 	setCorsHeaders(res);
+	const wire = providerKey === "azure" ? "Azure OpenAI Chat Completions" : providerKey === "openrouter" ? "OpenRouter Chat Completions" : providerKey === "byteplus" || bytePlusPath ? "BytePlus ModelArk Chat Completions" : "OpenAI Chat Completions";
 	let raw;
 	try {
 		raw = await require_helpers.readBody(req);
 	} catch (err) {
 		const msg = err instanceof Error ? err.message : "Failed to read request body";
 		const clientFault = err instanceof require_helpers.RequestBodyTooLargeError;
-		const route = `${req.method ?? "POST"} ${req.url ?? COMPLETIONS_PATH}`;
+		const route = `${req.method ?? "POST"} ${req.url ?? require_route_registry.COMPLETIONS_PATH}`;
 		const clientAbort = clientAbortedMidBody(req, res, err);
 		const bodyLimitDisconnect = clientFault && (req.destroyed || res.destroyed);
 		if (clientAbort || bodyLimitDisconnect) {
@@ -648,7 +901,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 			defaults.logger.warn(bodyLimitDisconnect ? `${route}: ${msg}` : `${route}: client aborted mid-body (${msg})`);
 			journal.add({
 				method: req.method ?? "POST",
-				path: req.url ?? COMPLETIONS_PATH,
+				path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 				headers: require_helpers.flattenHeaders(req.headers),
 				body: null,
 				response: {
@@ -665,7 +918,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		else defaults.logger.error(`${route}: ${msg}`);
 		journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: null,
 			response: {
@@ -686,7 +939,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		const detail = parseErr instanceof Error ? parseErr.message : "unknown parse error";
 		journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: null,
 			response: {
@@ -705,7 +958,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 	if (!require_helpers.isJsonObject(body)) {
 		journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: null,
 			response: {
@@ -723,7 +976,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 	if (!Array.isArray(body.messages)) {
 		journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: null,
 			response: {
@@ -739,8 +992,53 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		} }));
 		return;
 	}
+	const nullMessageIndex = body.messages.findIndex((message) => message === null);
+	if (nullMessageIndex !== -1) {
+		const message = `Invalid request: messages[${nullMessageIndex}] must be an object`;
+		journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 400,
+				fixture: null
+			}
+		});
+		require_sse_writer.writeErrorResponse(res, 400, openRouter ? require_openrouter_chat.serializeOpenRouterError(400, message) : JSON.stringify({ error: {
+			message,
+			type: "invalid_request_error",
+			param: null,
+			code: null
+		} }));
+		return;
+	}
+	if (new URL(req.url ?? require_route_registry.COMPLETIONS_PATH, "http://localhost").pathname === require_route_registry.COMPLETIONS_PATH) {
+		let toolsError = require_helpers.validateToolsField(body.tools);
+		if (!toolsError && Array.isArray(body.tools)) {
+			const nullFunctionIndex = body.tools.findIndex((tool) => tool?.function === null);
+			if (nullFunctionIndex !== -1) toolsError = `tools[${nullFunctionIndex}].function must not be null`;
+		}
+		if (toolsError) {
+			journal.add({
+				method: req.method ?? "POST",
+				path: req.url ?? require_route_registry.COMPLETIONS_PATH,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: null,
+				response: {
+					status: 400,
+					fixture: null
+				}
+			});
+			require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+				message: toolsError,
+				type: "invalid_request_error"
+			} }));
+			return;
+		}
+	}
 	const method = req.method ?? "POST";
-	const path = req.url ?? COMPLETIONS_PATH;
+	const path = req.url ?? require_route_registry.COMPLETIONS_PATH;
 	const flatHeaders = require_helpers.flattenHeaders(req.headers);
 	body._endpointType = "chat";
 	body._context = require_helpers.getContext(req);
@@ -754,6 +1052,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 	const openRouterFallback = openRouter && Array.isArray(body.models) && body.models.length > 0;
 	const selectFixture = (probe, counts) => {
 		for (;;) {
+			beforeFixtureSelection?.();
 			const attempt = require_router.matchFixtureDiagnostic(fixtures, probe, counts, defaults.requestTransform, matchOptions);
 			if (attempt.fixture && require_fixture_loader.isOneShotError(attempt.fixture) && !require_fixture_loader.claimOneShotError(fixtures, attempt.fixture)) continue;
 			return attempt;
@@ -837,13 +1136,32 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 	const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
 	const missWouldProxy = require_helpers.wouldProxyMiss(effectiveStrict, defaults.record, providerKey);
 	const noFixtureSource = missWouldProxy ? "proxy" : "internal";
+	const recordBypass = (reason) => {
+		const entry = getRequestEntry();
+		if (!entry) return;
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry,
+			summary: require_misbehavior.resolveMisbehaviorShortCircuit({
+				wire: "openai-chat",
+				fixture: fixture ?? void 0,
+				defaults,
+				rawHeaders: req.headers,
+				url: req.url,
+				reason
+			}),
+			defaults,
+			testId
+		});
+	};
 	if (chaosAction === "drop" || chaosAction === "disconnect" || chaosAction === "rateLimit") {
 		require_chaos.applyChaosAction(chaosAction, res, fixture, journal, chaosContext, fixture ? "fixture" : noFixtureSource, defaults.registry, defaults.logger);
+		recordBypass("chaos-fired");
 		require_fixture_loader.releaseOneShotError(fixtures, fixture);
 		return;
 	}
 	if (chaosAction === "malformed" && (fixture || !missWouldProxy)) {
 		require_chaos.applyChaosAction(chaosAction, res, fixture, journal, chaosContext, fixture ? "fixture" : "internal", defaults.registry, defaults.logger);
+		recordBypass("chaos-fired");
 		require_fixture_loader.releaseOneShotError(fixtures, fixture);
 		return;
 	}
@@ -851,10 +1169,10 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		if (effectiveStrict) {
 			const strictStatus = 503;
 			const strictMessage = require_helpers.strictNoMatchMessage(skippedBySequenceOrTurn);
-			defaults.logger.error(require_helpers.strictNoMatchLogLine(req.method ?? "POST", req.url ?? COMPLETIONS_PATH, skippedBySequenceOrTurn));
+			defaults.logger.error(require_helpers.strictNoMatchLogLine(req.method ?? "POST", req.url ?? require_route_registry.COMPLETIONS_PATH, skippedBySequenceOrTurn));
 			journal.add({
 				method: req.method ?? "POST",
-				path: req.url ?? COMPLETIONS_PATH,
+				path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 				headers: require_helpers.flattenHeaders(req.headers),
 				body,
 				response: {
@@ -875,6 +1193,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 			const hookOptions = chaosAction === "malformed" ? {
 				beforeWriteResponse: () => {
 					require_chaos.applyChaosAction(chaosAction, res, null, journal, chaosContext, "proxy", defaults.registry, defaults.logger);
+					recordBypass("chaos-fired");
 					return true;
 				},
 				onHookBypassed: (reason) => {
@@ -894,7 +1213,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 			req.socket?.on("error", noteClientHangUp);
 			let outcome;
 			try {
-				outcome = await require_recorder.proxyAndRecord(req, res, body, providerKey, req.url ?? COMPLETIONS_PATH, fixtures, defaults, raw, hookOptions);
+				outcome = await require_recorder.proxyAndRecord(req, res, body, providerKey, req.url ?? require_route_registry.COMPLETIONS_PATH, fixtures, defaults, raw, hookOptions);
 			} finally {
 				req.socket?.off("end", noteClientHangUp);
 				req.socket?.off("error", noteClientHangUp);
@@ -904,7 +1223,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				const destroyedMidStream = res.destroyed && !res.writableEnded;
 				journal.add({
 					method: req.method ?? "POST",
-					path: req.url ?? COMPLETIONS_PATH,
+					path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 					headers: require_helpers.flattenHeaders(req.headers),
 					body,
 					response: {
@@ -917,16 +1236,18 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 						} : {}
 					}
 				});
+				recordBypass("proxied");
 				return;
 			}
 			if (chaosAction === "malformed") {
 				require_chaos.applyChaosAction(chaosAction, res, null, journal, chaosContext, "internal", defaults.registry, defaults.logger);
+				recordBypass("chaos-fired");
 				return;
 			}
 		}
 		journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body,
 			response: {
@@ -943,13 +1264,71 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		} }));
 		return;
 	}
-	const response = preResolvedResponse ?? await require_helpers.resolveResponse(fixture, body);
+	const resolvedResponse = preResolvedResponse ?? await require_helpers.resolveResponse(fixture, body);
+	const evaluation = require_misbehavior.planMisbehavior({
+		wire: "openai-chat",
+		fixture,
+		response: resolvedResponse,
+		request: body,
+		stream: body.stream === true,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (evaluation.kind === "error") {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method,
+				path,
+				headers: flatHeaders,
+				body,
+				response: {
+					status: evaluation.status,
+					fixture
+				}
+			}),
+			summary: evaluation.summary,
+			defaults,
+			testId
+		});
+		if (!evaluation.summary?.evaluations.some((row) => row.outcome === "error")) defaults.logger.error(`${evaluation.code}: ${evaluation.message}`);
+		require_sse_writer.writeErrorResponse(res, evaluation.status, openRouter ? require_openrouter_chat.serializeOpenRouterError(evaluation.status, `${evaluation.code}: ${evaluation.message}`) : JSON.stringify({ error: {
+			message: evaluation.message,
+			type: "invalid_request_error",
+			param: null,
+			code: evaluation.code
+		} }));
+		return;
+	}
+	const appliedPlan = evaluation.kind === "applied" ? require_helpers.prepareOpenAIChatMisbehavior(evaluation) : void 0;
+	const response = appliedPlan?.response ?? resolvedResponse;
+	const summary = appliedPlan?.summary ?? evaluation.summary;
+	const recordOutcome = (entry) => {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry,
+			summary,
+			defaults,
+			testId
+		});
+	};
+	const appliedReasoning = appliedPlan && appliedPlan.reasoning === void 0 && (require_helpers.isTextResponse(response) || require_helpers.isToolCallResponse(response) || require_helpers.isCombinedFixtureResponse(response)) ? require_helpers.resolveReasoningForModel(response.reasoning, responseModel, require_helpers.resolveStrictMode(defaults.strict, req.headers), defaults.logger) : void 0;
+	const appliedUsage = appliedPlan ? require_helpers.resolveOpenAIChatMisbehaviorUsage(appliedPlan, body, appliedPlan.reasoning === void 0 ? appliedReasoning !== void 0 : openRouter) : void 0;
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const emitStreamingUsage = body.stream === true && body.stream_options?.include_usage === true || openRouter;
 	const streamingPromptText = body.messages.map((m) => typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => p.text ?? "").join("") : "").join("");
-	const resolveStreamingUsageTokens = (overrides, completionText) => require_helpers.resolveUsage(overrides, streamingPromptText, completionText);
+	const resolveStreamingUsageTokens = (overrides, completionText) => appliedUsage ?? require_helpers.resolveUsage(overrides, streamingPromptText, completionText);
+	const resolveRecordedTimings = (chunks) => {
+		const timings = fixture.recordedTimings;
+		if (!appliedPlan?.duplicateId || !timings) return timings;
+		const gaps = timings.interChunkDelaysMs;
+		return {
+			...timings,
+			interChunkDelaysMs: Array.from({ length: Math.max(gaps.length, chunks.length - 1) }, (_, index) => gaps[index] ?? gaps.at(-1) ?? 0)
+		};
+	};
 	const shapeORCompletion = (completion, overrides) => {
+		if (appliedUsage) completion.usage = appliedUsage;
 		if (!openRouter) return completion;
 		return require_openrouter_chat.shapeOpenRouterCompletion(completion, require_openrouter_chat.resolveOpenRouterShaping(overrides, overrides?.model ?? responseModel), overrides?.id !== void 0);
 	};
@@ -962,46 +1341,86 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 	const openRouterProcessing = !!(openRouter && fixture.openRouterProcessing);
 	if (require_helpers.isErrorResponse(response)) {
 		const status = response.status ?? 500;
-		journal.add({
+		recordOutcome(journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body,
 			response: {
 				status,
 				fixture
 			}
-		});
+		}));
 		require_sse_writer.writeErrorResponse(res, status, openRouter ? require_openrouter_chat.serializeOpenRouterError(status, response.error.message, response.error.metadata) : require_helpers.serializeErrorResponse(response), { retryAfter: response.retryAfter });
 		return;
 	}
 	if (require_helpers.isAudioResponse(response)) {
-		journal.add({
+		recordOutcome(journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body,
 			response: {
 				status: 422,
 				fixture
 			}
-		});
+		}));
 		require_sse_writer.writeErrorResponse(res, 422, openRouter ? require_openrouter_chat.serializeOpenRouterError(422, "Audio responses are not supported on the chat completions endpoint. Use Gemini generateContent or a dedicated audio endpoint.") : JSON.stringify({ error: {
 			message: "Audio responses are not supported on the chat completions endpoint. Use Gemini generateContent or a dedicated audio endpoint.",
 			type: "invalid_request_error"
 		} }));
 		return;
 	}
-	if (require_helpers.isContentWithToolCallsResponse(response)) {
+	if (appliedPlan && require_helpers.isTextResponse(response) && (appliedPlan.stop === "refusal" || appliedPlan.stop === "content_filter" || appliedPlan.reasoning !== void 0)) {
+		const overrides = require_helpers.extractOverrides(response);
+		const entry = journal.add({
+			method,
+			path,
+			headers: flatHeaders,
+			body,
+			response: {
+				status: 200,
+				fixture
+			}
+		});
+		recordOutcome(entry);
+		if (body.stream !== true) {
+			const completion = appliedPlan.stop === "refusal" ? require_helpers.buildOpenAIRefusalCompletion(appliedPlan.refusal ?? "", responseModel, overrides, body.messages) : appliedPlan.stop === "content_filter" ? require_helpers.buildOpenAIContentFilterCompletion(responseModel, overrides, body.messages) : require_helpers.buildOpenAIReasoningCompletion(appliedPlan.reasoning ?? "", responseModel, openRouter, overrides, body.messages);
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(shapeORCompletion(completion, overrides)));
+		} else {
+			const chunks = appliedPlan.stop === "refusal" ? require_helpers.buildOpenAIRefusalChunks(appliedPlan.refusal ?? "", responseModel, chunkSize, overrides) : appliedPlan.stop === "content_filter" ? require_helpers.buildOpenAIContentFilterChunks(responseModel, overrides) : require_helpers.buildOpenAIReasoningChunks(appliedPlan.reasoning ?? "", responseModel, chunkSize, openRouter, overrides);
+			const usageChunk = emitStreamingUsage ? require_helpers.buildUsageChunk(chunks[0].id, overrides?.model ?? responseModel, chunks[0].created, resolveStreamingUsageTokens(overrides, ""), overrides?.systemFingerprint) : void 0;
+			shapeORChunks(chunks, usageChunk, overrides);
+			const interruption = require_interruption.createInterruptionSignal(fixture);
+			if (!await require_sse_writer.writeSSEStream(res, chunks, {
+				latency,
+				streamingProfile: fixture.streamingProfile,
+				signal: interruption?.signal,
+				onChunkSent: interruption?.tick,
+				usageChunk,
+				recordedTimings: resolveRecordedTimings(chunks),
+				replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
+				openRouterProcessing
+			})) {
+				if (!res.writableEnded) res.destroy();
+				entry.response.interrupted = true;
+				entry.response.interruptReason = interruption?.reason();
+			}
+			interruption?.cleanup();
+		}
+		return;
+	}
+	if (require_helpers.isCombinedFixtureResponse(response)) {
 		if (response.webSearches?.length) defaults.logger.warn("webSearches in fixture response are not supported for Chat Completions API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
-		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, responseModel, effectiveStrict, defaults.logger);
+		const effReasoning = appliedPlan ? appliedReasoning : require_helpers.resolveReasoningForModel(response.reasoning, responseModel, effectiveStrict, defaults.logger);
 		const streaming = body.stream === true;
 		const blockOutcome = response.blocks && response.blocks.length > 0 ? require_helpers.resolveFixtureBlockOutcome(response.blocks) : void 0;
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body,
 			response: {
@@ -1009,16 +1428,18 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				fixture
 			}
 		});
+		recordOutcome(journalEntry);
+		const toolCalls = require_helpers.requireEmittedFunctionToolCalls(response, wire);
 		if (!streaming) {
-			const completion = require_helpers.buildContentWithToolCallsCompletion(blockOutcome?.content ?? response.content ?? "", blockOutcome?.toolCalls ?? response.toolCalls ?? [], responseModel, effReasoning, blockOutcome ? {
+			const completion = require_helpers.buildContentWithToolCallsCompletion(blockOutcome?.content ?? response.content ?? "", blockOutcome?.toolCalls ?? toolCalls, responseModel, effReasoning, blockOutcome ? {
 				...overrides,
 				finishReason: overrides?.finishReason ?? (blockOutcome.hasToolCalls ? "tool_calls" : "stop")
 			} : overrides, body.messages);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(shapeORCompletion(completion, overrides)));
 		} else {
-			const chunks = require_helpers.buildContentWithToolCallsChunks(blockOutcome?.content ?? response.content ?? "", blockOutcome?.toolCalls ?? response.toolCalls ?? [], responseModel, chunkSize, effReasoning, overrides, blockOutcome?.ordered);
-			const completionText = blockOutcome ? blockOutcome.content + blockOutcome.toolCalls.map((tc) => tc.name + tc.arguments).join("") : (response.content ?? "") + (response.toolCalls ?? []).map((tc) => tc.name + tc.arguments).join("");
+			const chunks = require_helpers.buildContentWithToolCallsChunks(blockOutcome?.content ?? response.content ?? "", blockOutcome?.toolCalls ?? toolCalls, responseModel, chunkSize, effReasoning, overrides, blockOutcome?.ordered);
+			const completionText = blockOutcome ? blockOutcome.content + blockOutcome.toolCalls.map((tc) => tc.name + tc.arguments).join("") : (response.content ?? "") + toolCalls.map((tc) => tc.name + tc.arguments).join("");
 			const usageChunk = emitStreamingUsage ? require_helpers.buildUsageChunk(chunks[0]?.id ?? "chatcmpl-unknown", overrides?.model ?? responseModel, chunks[0]?.created ?? Math.floor(Date.now() / 1e3), resolveStreamingUsageTokens(overrides, completionText), overrides?.systemFingerprint) : void 0;
 			shapeORChunks(chunks, usageChunk, overrides);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
@@ -1028,7 +1449,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				signal: interruption?.signal,
 				onChunkSent: interruption?.tick,
 				usageChunk,
-				recordedTimings: fixture.recordedTimings,
+				recordedTimings: resolveRecordedTimings(chunks),
 				replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
 				openRouterProcessing
 			})) {
@@ -1044,10 +1465,10 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		if (response.webSearches?.length) defaults.logger.warn("webSearches in fixture response are not supported for Chat Completions API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
-		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, responseModel, effectiveStrict, defaults.logger);
+		const effReasoning = appliedPlan ? appliedReasoning : require_helpers.resolveReasoningForModel(response.reasoning, responseModel, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body,
 			response: {
@@ -1055,6 +1476,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				fixture
 			}
 		});
+		recordOutcome(journalEntry);
 		if (body.stream !== true) {
 			const completion = require_helpers.buildTextCompletion(response.content, responseModel, effReasoning, overrides, body.messages);
 			res.writeHead(200, { "Content-Type": "application/json" });
@@ -1070,7 +1492,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				signal: interruption?.signal,
 				onChunkSent: interruption?.tick,
 				usageChunk,
-				recordedTimings: fixture.recordedTimings,
+				recordedTimings: resolveRecordedTimings(chunks),
 				replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
 				openRouterProcessing
 			})) {
@@ -1086,10 +1508,10 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		if (response.webSearches?.length) defaults.logger.warn("webSearches in fixture response are not supported for Chat Completions API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
-		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, responseModel, effectiveStrict, defaults.logger);
+		const effReasoning = appliedPlan ? appliedReasoning : require_helpers.resolveReasoningForModel(response.reasoning, responseModel, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
-			path: req.url ?? COMPLETIONS_PATH,
+			path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body,
 			response: {
@@ -1097,13 +1519,15 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				fixture
 			}
 		});
+		recordOutcome(journalEntry);
+		const toolCalls = require_helpers.requireServedFunctionToolCalls(response, wire);
 		if (body.stream !== true) {
-			const completion = require_helpers.buildToolCallCompletion(response.toolCalls, responseModel, effReasoning, overrides, body.messages);
+			const completion = require_helpers.buildToolCallCompletion(toolCalls, responseModel, effReasoning, overrides, body.messages);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(shapeORCompletion(completion, overrides)));
 		} else {
-			const chunks = require_helpers.buildToolCallChunks(response.toolCalls, responseModel, chunkSize, effReasoning, overrides);
-			const completionText = response.toolCalls.map((tc) => tc.name + tc.arguments).join("");
+			const chunks = require_helpers.buildToolCallChunks(toolCalls, responseModel, chunkSize, effReasoning, overrides);
+			const completionText = toolCalls.map((tc) => tc.name + tc.arguments).join("");
 			const usageChunk = emitStreamingUsage ? require_helpers.buildUsageChunk(chunks[0]?.id ?? "chatcmpl-unknown", overrides?.model ?? responseModel, chunks[0]?.created ?? Math.floor(Date.now() / 1e3), resolveStreamingUsageTokens(overrides, completionText), overrides?.systemFingerprint) : void 0;
 			shapeORChunks(chunks, usageChunk, overrides);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
@@ -1113,7 +1537,7 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 				signal: interruption?.signal,
 				onChunkSent: interruption?.tick,
 				usageChunk,
-				recordedTimings: fixture.recordedTimings,
+				recordedTimings: resolveRecordedTimings(chunks),
 				replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
 				openRouterProcessing
 			})) {
@@ -1125,16 +1549,16 @@ async function handleCompletions(req, res, fixtures, journal, defaults, modelFal
 		}
 		return;
 	}
-	journal.add({
+	recordOutcome(journal.add({
 		method: req.method ?? "POST",
-		path: req.url ?? COMPLETIONS_PATH,
+		path: req.url ?? require_route_registry.COMPLETIONS_PATH,
 		headers: require_helpers.flattenHeaders(req.headers),
 		body,
 		response: {
 			status: 500,
 			fixture
 		}
-	});
+	}));
 	require_sse_writer.writeErrorResponse(res, 500, openRouter ? require_openrouter_chat.serializeOpenRouterError(500, "Fixture response did not match any known type") : JSON.stringify({ error: {
 		message: "Fixture response did not match any known type",
 		type: "server_error"
@@ -1148,18 +1572,101 @@ async function createServer(fixtures, options, mounts, serviceFixtures) {
 }
 /** @internal Config startup uses this to avoid parsing a selected auth source twice. */
 async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mounts, serviceFixtures) {
+	const logger = new require_logger.Logger(options?.logLevel ?? "silent");
+	const mountList = mounts ?? [];
+	const handOff = serviceFixtures?.mcpFakes && serviceFixtures.mcpFakes.length > 0 ? require_mcp_fakes_mount.handOffMcpFakes(mountList, serviceFixtures.mcpFakes, logger) : null;
+	try {
+		return await startServer(fixtures, options, resolvedAuth, mountList, logger, serviceFixtures, () => handOff?.commit());
+	} catch (err) {
+		handOff?.undo();
+		throw err;
+	}
+}
+/**
+* The journal as JSON. An entry names the caller's fixture; the JSON shows
+* the fixture the request was served from (`Journal.servedFixture`): an
+* extended server's view, with the held keys applied, or LLMock's
+* per-addition copy with misbehavior enabled. The journal therefore reads as
+* it did when the entries held those objects.
+*/
+function journalJson(entries, journal) {
+	if (!entries.some((entry) => journal.servedFixture(entry) !== entry.response.fixture)) return JSON.stringify(entries);
+	return JSON.stringify(entries.map((entry) => {
+		const fixture = entry.response.fixture;
+		let served = journal.servedFixture(entry);
+		if (served === fixture || !served) return entry;
+		const viewSource = require_fixture_loader.responsesToolsViewSource(served);
+		if (viewSource !== served) served = require_fixture_loader.responsesToolsExtendedView(viewSource);
+		return {
+			...entry,
+			response: {
+				...entry.response,
+				fixture: served
+			}
+		};
+	}));
+}
+/**
+* The server of `createServerWithResolvedAuth`, after the MCP fakes hand-off.
+* `commitHandOff` runs once the server listens; if it throws, the server is
+* closed and start rejects.
+*/
+async function startServer(fixtures, options, resolvedAuth, mountList, logger, serviceFixtures, commitHandOff) {
+	const callerFixtures = fixtures;
+	let rawFixtureAddition = 0;
+	function ensureRawFixturePositions() {
+		const existingPositions = new Set(callerFixtures.map(require_misbehavior.getFixtureMisbehaviorPosition).filter((position) => position !== void 0));
+		for (const fixture of callerFixtures) {
+			if (require_misbehavior.getFixtureMisbehaviorPosition(fixture) !== void 0) continue;
+			let position;
+			do
+				position = `createServer#${rawFixtureAddition++}`;
+			while (existingPositions.has(position));
+			require_misbehavior.setFixtureMisbehaviorPosition(fixture, position);
+			existingPositions.add(position);
+		}
+	}
+	ensureRawFixturePositions();
 	const host = options?.host ?? "127.0.0.1";
 	const port = options?.port ?? 0;
-	const logger = new require_logger.Logger(options?.logLevel ?? "silent");
 	const registry = options?.metrics ? require_metrics.createMetricsRegistry() : void 0;
 	const serverOptions = options ?? {};
+	const validResponsesTools = (mode) => mode === "legacy" || mode === "extended";
+	if (serverOptions.responsesTools !== void 0 && !validResponsesTools(serverOptions.responsesTools)) new require_logger.Logger("warn").warn(`Ignoring responsesTools because it must be "legacy" or "extended", got ${JSON.stringify(serverOptions.responsesTools)}. Using "legacy".`);
+	fixtures = require_helpers.createServerFixtureList(callerFixtures, () => serverOptions.responsesTools, require_fixture_loader.responsesToolsExtendedView);
 	const chaosByTestId = /* @__PURE__ */ new Map();
+	let misbehaviorBaseline;
+	const misbehavior = {
+		byTestId: /* @__PURE__ */ new Map(),
+		get baseline() {
+			return this.byTestId.get(require_constants.DEFAULT_TEST_ID) ?? misbehaviorBaseline;
+		},
+		set baseline(config) {
+			misbehaviorBaseline = config;
+			if (config === void 0) this.byTestId.delete(require_constants.DEFAULT_TEST_ID);
+			else if (this.byTestId.has(require_constants.DEFAULT_TEST_ID)) this.byTestId.set(require_constants.DEFAULT_TEST_ID, config);
+		}
+	};
+	const misbehaviorEnabled = serverOptions.enableMisbehavior === true;
+	if (misbehaviorEnabled) callerFixtures.forEach(require_fixture_loader.enableHeldFixtureMisbehavior);
+	if (misbehaviorEnabled && serverOptions.misbehavior !== void 0) {
+		const parsed = require_misbehavior.parseMisbehavior(serverOptions.misbehavior);
+		if (!parsed.ok) throw new TypeError(`${parsed.issue.rule}: ${parsed.issue.message}`);
+		misbehavior.baseline = parsed.config.seed === "random" ? {
+			...parsed.config,
+			seed: require_misbehavior.resolveMisbehaviorSeed(parsed.config.seed, logger)
+		} : parsed.config;
+	}
 	const defaults = {
 		latency: serverOptions.latency ?? 0,
 		chunkSize: Math.max(1, serverOptions.chunkSize ?? DEFAULT_CHUNK_SIZE),
 		replaySpeed: serverOptions.replaySpeed ?? 1,
 		logger,
 		chaosByTestId,
+		misbehavior: misbehaviorEnabled ? misbehavior : void 0,
+		get misbehaviorCounters() {
+			return journal;
+		},
 		get chaos() {
 			return {
 				base: chaosByTestId.get(require_constants.DEFAULT_TEST_ID) ?? serverOptions.chaos,
@@ -1182,6 +1689,13 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 		get strict() {
 			return serverOptions.strict;
 		},
+		get strictToolArguments() {
+			return serverOptions.strictToolArguments;
+		},
+		get responsesTools() {
+			const mode = serverOptions.responsesTools;
+			return validResponsesTools(mode) ? mode : void 0;
+		},
 		get requestTransform() {
 			return serverOptions.requestTransform;
 		},
@@ -1272,6 +1786,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			if (req) ownJournalEntry.set(req, entry);
 		}
 	});
+	if (serverOptions.responsesTools === "extended") journal.configureFixtureViewSource(require_fixture_loader.responsesToolsViewSource);
 	const videoStates = new require_video.VideoStateMap();
 	const openRouterVideoJobs = new require_openrouter_video.OpenRouterVideoJobMap();
 	const veoVideoJobs = new require_veo_video.VeoVideoJobMap();
@@ -1286,6 +1801,85 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 		return status >= 400 && status < 500 ? "invalid_request_error" : "server_error";
 	}
 	/**
+	* Envelope for a fixture tool-call error (see isFixtureToolCallError: invalid
+	* JSON arguments on an object wire, a custom tool call on a non-Responses
+	* wire, or a malformed fixture tool call). It is the provider envelope aimock
+	* emits for that route, with the aimock `code` in it: Google's
+	* `google.rpc.ErrorInfo` detail on Gemini and Vertex AI, a string
+	* `error.code` on Gemini Interactions and Anthropic Messages, a `reason`
+	* member on Bedrock (a `code` member would replace `__type` as the AWS SDK's
+	* error name), and a sibling `code` on Ollama's bare string error. Every
+	* other route, Cohere included, gets the OpenAI-style
+	* `{error: {message, type, code}}`. OpenRouter routes pass their own
+	* `toolCallEnvelope` instead of using this one.
+	*/
+	function invalidToolArgumentsEnvelope(pathname, message, code) {
+		if (pathname === require_route_registry.OLLAMA_CHAT_PATH) return JSON.stringify({
+			error: message,
+			code
+		});
+		if (pathname === require_route_registry.GEMINI_INTERACTIONS_PATH) return JSON.stringify({ error: {
+			code,
+			message
+		} });
+		if (require_route_registry.GEMINI_PATH_RE.test(pathname) || require_route_registry.VERTEX_AI_RE.test(pathname)) return JSON.stringify({ error: {
+			code: 500,
+			message,
+			status: "INTERNAL",
+			details: require_helpers.googleFixtureToolCallErrorDetails(code)
+		} });
+		if (pathname === require_route_registry.MESSAGES_PATH) return JSON.stringify({
+			type: "error",
+			error: {
+				type: "api_error",
+				code,
+				message
+			}
+		});
+		if (require_route_registry.BEDROCK_INVOKE_RE.test(pathname) || require_route_registry.BEDROCK_STREAM_RE.test(pathname) || require_route_registry.BEDROCK_CONVERSE_RE.test(pathname) || require_route_registry.BEDROCK_CONVERSE_STREAM_RE.test(pathname)) return JSON.stringify({
+			__type: "InternalServerException",
+			message,
+			reason: code
+		});
+		return JSON.stringify({ error: {
+			message,
+			type: "server_error",
+			code
+		} });
+	}
+	function invalidMisbehaviorHeaderEnvelope(pathname, detail) {
+		const code = "aimock_misbehavior_invalid";
+		const message = `${code}: ${detail}`;
+		if (pathname === require_route_registry.OLLAMA_CHAT_PATH || pathname === require_route_registry.OLLAMA_GENERATE_PATH) return JSON.stringify({ error: message });
+		if (pathname === require_route_registry.COHERE_CHAT_PATH) return JSON.stringify({ message });
+		if (pathname === require_route_registry.GEMINI_INTERACTIONS_PATH) return JSON.stringify({ error: {
+			code,
+			message
+		} });
+		if (require_route_registry.GEMINI_PATH_RE.test(pathname) || require_route_registry.VERTEX_AI_RE.test(pathname)) return JSON.stringify({ error: {
+			code: 400,
+			message,
+			status: "INVALID_ARGUMENT"
+		} });
+		if (pathname === require_route_registry.MESSAGES_PATH) return JSON.stringify({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				code,
+				message
+			}
+		});
+		if (require_route_registry.BEDROCK_INVOKE_RE.test(pathname) || require_route_registry.BEDROCK_STREAM_RE.test(pathname) || require_route_registry.BEDROCK_CONVERSE_RE.test(pathname) || require_route_registry.BEDROCK_CONVERSE_STREAM_RE.test(pathname)) return JSON.stringify({
+			__type: "ValidationException",
+			message
+		});
+		return JSON.stringify({ error: {
+			message,
+			type: "invalid_request_error",
+			code
+		} });
+	}
+	/**
 	* The newest journal entry this request already produced, or null.
 	*
 	* Attribution is by the identity of the `IncomingMessage` the entry was
@@ -1336,6 +1930,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 	function routeError(req, res, err, pathname, opts) {
 		const route = `${req.method ?? "?"} ${pathname}`;
 		const msg = err instanceof Error ? err.message : "Internal error";
+		const invalidToolArguments = require_helpers.isFixtureToolCallError(err);
 		const clientFault = err instanceof require_helpers.RequestBodyTooLargeError;
 		const clientAbort = clientAbortedMidBody(req, res, err);
 		const status = clientFault ? 400 : 500;
@@ -1376,8 +1971,10 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			return;
 		}
 		if (!res.headersSent) {
-			if (existing) existing.response.status = status;
-			else try {
+			if (existing) {
+				existing.response.status = status;
+				if (invalidToolArguments) existing.response.error = msg;
+			} else try {
 				journal.add({
 					method: req.method ?? "?",
 					path: req.url ?? "?",
@@ -1387,14 +1984,15 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 					response: {
 						status,
 						fixture: null,
-						source: "internal"
+						source: "internal",
+						...invalidToolArguments ? { error: msg } : {}
 					}
 				});
 			} catch (jErr) {
 				logger.warn(`${route}: journal write failed after handler error: ${jErr instanceof Error ? jErr.message : String(jErr)}`);
 			}
 			setCorsHeaders(res);
-			require_sse_writer.writeErrorResponse(res, status, opts?.envelope ? opts.envelope(msg, status) : JSON.stringify({ error: {
+			require_sse_writer.writeErrorResponse(res, status, invalidToolArguments ? (opts?.toolCallEnvelope ?? ((m, c) => invalidToolArgumentsEnvelope(pathname, m, c)))(msg, require_helpers.fixtureToolCallErrorCode(err)) : opts?.envelope ? opts.envelope(msg, status) : JSON.stringify({ error: {
 				message: msg,
 				type: errorTypeForStatus(status)
 			} }));
@@ -1439,16 +2037,21 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			else res.destroy();
 		}
 	}
-	if (mounts) for (const { handler } of mounts) {
+	for (const { handler } of mountList) {
 		if (handler.setJournal) handler.setJournal(journal);
 		if (registry && handler.setRegistry) handler.setRegistry(registry);
+		if (handler.setLogger) handler.setLogger(logger);
+		if (handler instanceof require_mcp_mock.MCPMock) handler.setReplaySpeed(defaults.replaySpeed);
 	}
 	if (registry) registry.setGauge("aimock_fixtures_loaded", {}, fixtures.length);
 	const server = node_http.createServer((req, res) => {
 		requestScope.run(req, () => {
-			handleHttpRequest(req, res).catch((err) => {
+			require_helpers.runWithToolArgumentsScope({
+				strict: defaults.strictToolArguments === true,
+				logger
+			}, () => handleHttpRequest(req, res).catch((err) => {
 				routeError(req, res, err, req.url ?? "?");
-			});
+			}));
 		});
 	});
 	async function handleHttpRequest(req, res) {
@@ -1464,7 +2067,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				if (recorded) return;
 				recorded = true;
 				try {
-					const normalizedPath = require_metrics.normalizePathLabel(pathname, mounts ? mounts.map((m) => m.path) : []);
+					const normalizedPath = require_metrics.normalizePathLabel(pathname, mountList.map((m) => m.path));
 					const method = req.method ?? "UNKNOWN";
 					registry.incrementCounter("aimock_requests_total", {
 						method,
@@ -1485,7 +2088,36 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				if (!res.writableFinished) recordOutcome(require_metrics.DESTROYED_STATUS_LABEL);
 			});
 		}
-		const parsedUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		let parsedUrl;
+		try {
+			parsedUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		} catch (err) {
+			const route = `${req.method ?? "?"} ${req.url ?? "?"}`;
+			const msg = err instanceof Error ? err.message : "Internal error";
+			logger.error(`${route}: ${msg}`);
+			if (err instanceof Error && err.stack) logger.debug(err.stack);
+			try {
+				journal.add({
+					method: req.method ?? "?",
+					path: req.url ?? "?",
+					headers: require_helpers.flattenHeaders(req.headers),
+					body: null,
+					response: {
+						status: 400,
+						fixture: null,
+						source: "internal"
+					}
+				});
+			} catch (jErr) {
+				logger.warn(`${route}: journal write failed after handler error: ${jErr instanceof Error ? jErr.message : String(jErr)}`);
+			}
+			setCorsHeaders(res);
+			require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+				message: "Invalid request target",
+				type: "invalid_request_error"
+			} }));
+			return;
+		}
 		pathname = parsedUrl.pathname;
 		const originalPathname = pathname;
 		const isOpenRouter = require_openrouter_chat.isOpenRouterPath(originalPathname);
@@ -1494,48 +2126,74 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			handleOptions(res);
 			return;
 		}
-		if (!(req.method === "GET" && (pathname === HEALTH_PATH || pathname === READY_PATH || pathname === "/metrics"))) {
+		if (!(req.method === "GET" && (pathname === require_route_registry.HEALTH_PATH || pathname === require_route_registry.READY_PATH || pathname === require_route_registry.METRICS_PATH))) {
 			if (!require_api_key_auth.validateRequestApiKey(req, resolvedAuth.policy).ok) {
 				require_api_key_auth.writeApiKeyHttpRejection(res, setCorsHeaders);
 				return;
 			}
 			require_api_key_auth.markAuthenticatedRequest(req, resolvedAuth.policy);
 		}
-		if (pathname.startsWith(CONTROL_PREFIX)) {
-			await handleControlAPI(req, res, pathname, parsedUrl.searchParams, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults);
+		if (pathname.startsWith(require_route_registry.CONTROL_PREFIX)) {
+			ensureRawFixturePositions();
+			await handleControlAPI(req, res, pathname, parsedUrl.searchParams, fixtures, journal, videoStates, openRouterVideoJobs, veoVideoJobs, grokVideoJobs, bytePlusVideoJobs, defaults, mountList);
 			return;
 		}
-		if (mounts) {
-			for (const { path: mountPath, handler } of mounts) if (pathname === mountPath || pathname.startsWith(mountPath + "/")) {
-				const subPath = pathname.slice(mountPath.length) || "/";
-				if (await handler.handleRequest(req, res, subPath)) return;
-			}
+		const misbehaviorHeader = defaults.misbehavior ? require_misbehavior.parseMisbehaviorHeader(req.headers["x-aimock-misbehavior"]) : void 0;
+		if (misbehaviorHeader && !misbehaviorHeader.ok) {
+			const detail = misbehaviorHeader.issue.message;
+			const message = `aimock_misbehavior_invalid: ${detail}`;
+			logger.error(`${req.method ?? "?"} ${pathname}: ${message}`);
+			journal.add({
+				method: req.method ?? "?",
+				path: req.url ?? pathname,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: null,
+				response: {
+					status: 400,
+					fixture: null,
+					source: "internal",
+					error: message
+				}
+			});
+			setCorsHeaders(res);
+			require_sse_writer.writeErrorResponse(res, 400, invalidMisbehaviorHeaderEnvelope(normalizeCompatPath(pathname), detail));
+			return;
 		}
-		if (pathname === OLLAMA_CHAT_PATH && req.method === "POST") {
+		for (const { path: mountPath, handler } of mountList) if (pathname === mountPath || pathname.startsWith(mountPath + "/")) {
+			const subPath = pathname.slice(mountPath.length) || "/";
+			if (await handler.handleRequest(req, res, subPath)) return;
+		}
+		if (pathname === require_route_registry.OLLAMA_CHAT_PATH && req.method === "POST") {
 			try {
-				await require_ollama.handleOllama(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_ollama.handleOllama(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === OLLAMA_GENERATE_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.OLLAMA_GENERATE_PATH && req.method === "POST") {
 			try {
-				await require_ollama.handleOllamaGenerate(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_ollama.handleOllamaGenerate(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if ((pathname === OLLAMA_EMBEDDINGS_PATH || pathname === OLLAMA_EMBED_PATH) && req.method === "POST") {
+		if ((pathname === require_route_registry.OLLAMA_EMBEDDINGS_PATH || pathname === require_route_registry.OLLAMA_EMBED_PATH) && req.method === "POST") {
 			try {
-				await require_ollama.handleOllamaEmbeddings(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_ollama.handleOllamaEmbeddings(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === OLLAMA_TAGS_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.OLLAMA_TAGS_PATH && req.method === "GET") {
 			setCorsHeaders(res);
 			const modelIds = /* @__PURE__ */ new Set();
 			for (const f of fixtures) if (f.match.model && typeof f.match.model === "string") modelIds.add(f.match.model);
@@ -1551,7 +2209,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			res.end(JSON.stringify({ models }));
 			return;
 		}
-		const openRouterVideoContentMatch = pathname.match(require_metrics.OPENROUTER_VIDEO_CONTENT_RE);
+		const openRouterVideoContentMatch = pathname.match(require_route_registry.OPENROUTER_VIDEO_CONTENT_RE);
 		if (openRouterVideoContentMatch && req.method === "GET") {
 			try {
 				await require_openrouter_video.handleOpenRouterVideoContent(req, res, openRouterVideoContentMatch[1], journal, defaults, setCorsHeaders, openRouterVideoJobs);
@@ -1560,77 +2218,85 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === OPENROUTER_VIDEO_MODELS_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.OPENROUTER_VIDEO_MODELS_PATH && req.method === "GET") {
 			try {
+				ensureRawFixturePositions();
 				await require_openrouter_video.handleOpenRouterVideoModels(req, res, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const openRouterVideoStatusMatch = pathname.match(require_metrics.OPENROUTER_VIDEO_STATUS_RE);
+		const openRouterVideoStatusMatch = pathname.match(require_route_registry.OPENROUTER_VIDEO_STATUS_RE);
 		if (openRouterVideoStatusMatch && req.method === "GET") {
 			try {
+				ensureRawFixturePositions();
 				await require_openrouter_video.handleOpenRouterVideoStatus(req, res, openRouterVideoStatusMatch[1], fixtures, journal, defaults, setCorsHeaders, openRouterVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === OPENROUTER_VIDEOS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.OPENROUTER_VIDEOS_PATH && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_openrouter_video.handleOpenRouterVideoCreate(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, openRouterVideoJobs);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_openrouter_video.handleOpenRouterVideoCreate(req, res, raw, fixtures, journal, defaults, setCorsHeaders, openRouterVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const bytePlusVideoStatusMatch = pathname.match(require_metrics.BYTEPLUS_VIDEO_STATUS_RE);
+		const bytePlusVideoStatusMatch = pathname.match(require_route_registry.BYTEPLUS_VIDEO_STATUS_RE);
 		if (bytePlusVideoStatusMatch && req.method === "GET") {
 			try {
+				ensureRawFixturePositions();
 				await require_byteplus_video.handleBytePlusVideoStatus(req, res, bytePlusVideoStatusMatch[1], fixtures, journal, defaults, setCorsHeaders, bytePlusVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (require_metrics.BYTEPLUS_VIDEO_SUBMIT_RE.test(pathname) && req.method === "POST") {
+		if (require_route_registry.BYTEPLUS_VIDEO_SUBMIT_RE.test(pathname) && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_byteplus_video.handleBytePlusVideoCreate(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, bytePlusVideoJobs);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_byteplus_video.handleBytePlusVideoCreate(req, res, raw, fixtures, journal, defaults, setCorsHeaders, bytePlusVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === "/api/v1/models" && req.method === "GET") {
+		if (pathname === require_route_registry.OPENROUTER_MODELS_PATH && req.method === "GET") {
+			ensureRawFixturePositions();
 			require_openrouter_chat.handleOpenRouterModels(req, res, fixtures, journal, defaults, setCorsHeaders);
 			return;
 		}
-		if (pathname === "/api/v1/key" && req.method === "GET") {
+		if (pathname === require_route_registry.OPENROUTER_KEY_PATH && req.method === "GET") {
 			require_openrouter_chat.handleOpenRouterKey(req, res, journal, setCorsHeaders);
 			return;
 		}
-		if (pathname === "/api/v1/credits" && req.method === "GET") {
+		if (pathname === require_route_registry.OPENROUTER_CREDITS_PATH && req.method === "GET") {
 			require_openrouter_chat.handleOpenRouterCredits(req, res, journal, setCorsHeaders);
 			return;
 		}
 		let azureDeploymentId;
-		const azureMatch = pathname.match(AZURE_DEPLOYMENT_RE);
+		const azureMatch = pathname.match(require_route_registry.AZURE_DEPLOYMENT_RE);
 		if (azureMatch && req.method === "POST") {
 			azureDeploymentId = azureMatch[1];
 			pathname = `/v1/${azureMatch[2]}`;
 		}
 		if (!azureDeploymentId) pathname = normalizeCompatPath(pathname, logger);
-		if (pathname === HEALTH_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.HEALTH_PATH && req.method === "GET") {
 			setCorsHeaders(res);
-			if (mounts && mounts.length > 0) {
+			if (mountList.length > 0) {
 				const services = { llm: {
 					status: "ok",
 					fixtures: fixtures.length
 				} };
-				for (const { path: mountPath, handler } of mounts) if (handler.health) {
+				for (const { path: mountPath, handler } of mountList) if (handler.health) {
 					const name = mountPath.replace(/^\//, "");
 					services[name] = handler.health();
 				}
@@ -1645,13 +2311,13 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === READY_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.READY_PATH && req.method === "GET") {
 			setCorsHeaders(res);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify({ status: "ready" }));
 			return;
 		}
-		if (pathname === "/metrics" && req.method === "GET") {
+		if (pathname === require_route_registry.METRICS_PATH && req.method === "GET") {
 			if (!registry) {
 				handleNotFound(res, "Not found");
 				return;
@@ -1661,7 +2327,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			res.end(registry.serialize());
 			return;
 		}
-		if (pathname === MODELS_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.MODELS_PATH && req.method === "GET") {
 			setCorsHeaders(res);
 			const modelIds = /* @__PURE__ */ new Set();
 			for (const f of fixtures) if (f.match.model && typeof f.match.model === "string") modelIds.add(f.match.model);
@@ -1678,7 +2344,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}));
 			return;
 		}
-		const batchesCancelMatch = pathname.match(BATCHES_CANCEL_RE);
+		const batchesCancelMatch = pathname.match(require_route_registry.BATCHES_CANCEL_RE);
 		if (batchesCancelMatch && req.method === "POST") {
 			try {
 				await require_helpers.readBody(req);
@@ -1688,7 +2354,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		const batchesIdMatch = pathname.match(BATCHES_ID_RE);
+		const batchesIdMatch = pathname.match(require_route_registry.BATCHES_ID_RE);
 		if (batchesIdMatch && req.method === "GET") {
 			try {
 				await require_batches.handleBatchesRetrieve(req, res, batchesIdMatch[1], journal, defaults, setCorsHeaders);
@@ -1697,7 +2363,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === BATCHES_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.BATCHES_PATH && req.method === "GET") {
 			try {
 				await require_batches.handleBatchesList(req, res, journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -1705,7 +2371,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === BATCHES_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.BATCHES_PATH && req.method === "POST") {
 			try {
 				await require_batches.handleBatchesCreate(req, res, await require_helpers.readBody(req), journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -1713,7 +2379,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		const filesContentMatch = pathname.match(require_metrics.FILES_CONTENT_RE);
+		const filesContentMatch = pathname.match(require_route_registry.FILES_CONTENT_RE);
 		if (filesContentMatch && req.method === "GET") {
 			try {
 				await require_files.handleFilesContent(req, res, filesContentMatch[1], journal, defaults, setCorsHeaders);
@@ -1722,7 +2388,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		const filesIdMatch = pathname.match(require_metrics.FILES_ID_RE);
+		const filesIdMatch = pathname.match(require_route_registry.FILES_ID_RE);
 		if (filesIdMatch && req.method === "GET") {
 			try {
 				await require_files.handleFilesRetrieve(req, res, filesIdMatch[1], journal, defaults, setCorsHeaders);
@@ -1739,7 +2405,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === FILES_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.FILES_PATH && req.method === "GET") {
 			try {
 				await require_files.handleFilesList(req, res, journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -1747,7 +2413,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === FILES_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.FILES_PATH && req.method === "POST") {
 			try {
 				await require_files.handleFilesCreate(req, res, (await require_helpers.readBodyBufferBounded(req, require_files.FILES_BODY_MAX_BYTES, require_files.FILES_BODY_DRAIN_MAX_BYTES)).buffer ?? require_files.FILES_BODY_OVERSIZED, journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -1755,7 +2421,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		const ftCancelMatch = pathname.match(FINE_TUNING_CANCEL_RE);
+		const ftCancelMatch = pathname.match(require_route_registry.FINE_TUNING_CANCEL_RE);
 		if (ftCancelMatch && req.method === "POST") {
 			try {
 				await require_helpers.readBody(req);
@@ -1765,7 +2431,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		const ftEventsMatch = pathname.match(FINE_TUNING_EVENTS_RE);
+		const ftEventsMatch = pathname.match(require_route_registry.FINE_TUNING_EVENTS_RE);
 		if (ftEventsMatch && req.method === "GET") {
 			try {
 				await require_fine_tuning.handleFineTuningEvents(req, res, ftEventsMatch[1], journal, defaults, setCorsHeaders);
@@ -1774,7 +2440,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		const ftIdMatch = pathname.match(FINE_TUNING_ID_RE);
+		const ftIdMatch = pathname.match(require_route_registry.FINE_TUNING_ID_RE);
 		if (ftIdMatch && req.method === "GET") {
 			try {
 				await require_fine_tuning.handleFineTuningRetrieve(req, res, ftIdMatch[1], journal, defaults, setCorsHeaders);
@@ -1783,7 +2449,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === FINE_TUNING_JOBS_PATH && req.method === "GET") {
+		if (pathname === require_route_registry.FINE_TUNING_JOBS_PATH && req.method === "GET") {
 			try {
 				await require_fine_tuning.handleFineTuningList(req, res, journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -1791,7 +2457,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === FINE_TUNING_JOBS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.FINE_TUNING_JOBS_PATH && req.method === "POST") {
 			try {
 				await require_fine_tuning.handleFineTuningCreate(req, res, await require_helpers.readBody(req), journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -1799,14 +2465,140 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === REQUESTS_PATH) {
+		const vsSearchMatch = pathname.match(require_route_registry.VECTOR_STORES_SEARCH_RE);
+		if (vsSearchMatch && req.method === "POST") {
+			try {
+				const raw = await require_helpers.readBody(req);
+				await require_vector_stores.handleVectorStoresSearch(req, res, vsSearchMatch[1], raw, journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		const vsBatchFilesMatch = pathname.match(require_route_registry.VECTOR_STORES_BATCH_FILES_RE);
+		if (vsBatchFilesMatch && req.method === "GET") {
+			try {
+				await require_vector_stores.handleVectorFileBatchesFiles(req, res, vsBatchFilesMatch[1], vsBatchFilesMatch[2], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		const vsBatchCancelMatch = pathname.match(require_route_registry.VECTOR_STORES_BATCH_CANCEL_RE);
+		if (vsBatchCancelMatch && req.method === "POST") {
+			try {
+				await require_helpers.readBody(req);
+				await require_vector_stores.handleVectorFileBatchesCancel(req, res, vsBatchCancelMatch[1], vsBatchCancelMatch[2], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		const vsBatchMatch = pathname.match(require_route_registry.VECTOR_STORES_BATCH_RE);
+		if (vsBatchMatch && req.method === "GET") {
+			try {
+				await require_vector_stores.handleVectorFileBatchesRetrieve(req, res, vsBatchMatch[1], vsBatchMatch[2], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		const vsFileMatch = pathname.match(require_route_registry.VECTOR_STORES_FILE_RE);
+		if (vsFileMatch && req.method === "GET") {
+			try {
+				await require_vector_stores.handleVectorStoreFilesRetrieve(req, res, vsFileMatch[1], vsFileMatch[2], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (vsFileMatch && req.method === "DELETE") {
+			try {
+				await require_vector_stores.handleVectorStoreFilesDelete(req, res, vsFileMatch[1], vsFileMatch[2], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		const vsIdMatch = pathname.match(require_route_registry.VECTOR_STORES_ID_RE);
+		if (vsIdMatch && req.method === "GET") {
+			try {
+				await require_vector_stores.handleVectorStoresRetrieve(req, res, vsIdMatch[1], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (vsIdMatch && req.method === "POST") {
+			try {
+				const raw = await require_helpers.readBody(req);
+				await require_vector_stores.handleVectorStoresModify(req, res, vsIdMatch[1], raw, journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (vsIdMatch && req.method === "DELETE") {
+			try {
+				await require_vector_stores.handleVectorStoresDelete(req, res, vsIdMatch[1], journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (require_route_registry.VECTOR_STORES_FILES_RE.test(pathname) && req.method === "POST") {
+			try {
+				const raw = await require_helpers.readBody(req);
+				const storeId = pathname.split("/")[3];
+				await require_vector_stores.handleVectorStoreFilesCreate(req, res, storeId, raw, journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (require_route_registry.VECTOR_STORES_FILES_RE.test(pathname) && req.method === "GET") {
+			try {
+				const storeId = pathname.split("/")[3];
+				await require_vector_stores.handleVectorStoreFilesList(req, res, storeId, journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (require_route_registry.VECTOR_STORES_FILE_BATCHES_RE.test(pathname) && req.method === "POST") {
+			try {
+				const raw = await require_helpers.readBody(req);
+				const storeId = pathname.split("/")[3];
+				await require_vector_stores.handleVectorFileBatchesCreate(req, res, storeId, raw, journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (pathname === require_route_registry.VECTOR_STORES_PATH && req.method === "GET") {
+			try {
+				await require_vector_stores.handleVectorStoresList(req, res, journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (pathname === require_route_registry.VECTOR_STORES_PATH && req.method === "POST") {
+			try {
+				await require_vector_stores.handleVectorStoresCreate(req, res, await require_helpers.readBody(req), journal, defaults, setCorsHeaders);
+			} catch (err) {
+				routeError(req, res, err, pathname, { service: "vector-stores" });
+			}
+			return;
+		}
+		if (pathname === require_route_registry.REQUESTS_PATH) {
 			setCorsHeaders(res);
 			if (req.method === "GET") {
 				const limitParam = parsedUrl.searchParams.get("limit");
 				let opts;
 				if (limitParam) {
-					const limit = parseInt(limitParam, 10);
-					if (Number.isNaN(limit) || limit <= 0) {
+					const limit = Number(limitParam);
+					if (!/^\+?\d+$/.test(limitParam.trim()) || !Number.isSafeInteger(limit) || limit <= 0) {
 						require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
 							message: `Invalid limit parameter: "${limitParam}"`,
 							type: "invalid_request_error"
@@ -1817,7 +2609,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				}
 				const entries = journal.getAll(opts);
 				res.writeHead(200, { "Content-Type": "application/json" });
-				res.end(JSON.stringify(entries));
+				res.end(journalJson(entries, journal));
 				return;
 			}
 			if (req.method === "DELETE") {
@@ -1829,39 +2621,47 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			handleNotFound(res, "Not found");
 			return;
 		}
-		if (pathname === RESPONSES_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.RESPONSES_PATH && req.method === "POST") {
 			try {
-				await require_responses.handleResponses(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_responses.handleResponses(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname, { streamEvent: (m) => `event: error\ndata: ${JSON.stringify({ error: { message: m } })}\n\n` });
 			}
 			return;
 		}
-		if (pathname === MESSAGES_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.MESSAGES_PATH && req.method === "POST") {
 			try {
-				await require_messages.handleMessages(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_messages.handleMessages(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname, { streamEvent: (m) => `event: error\ndata: ${JSON.stringify({ error: { message: m } })}\n\n` });
 			}
 			return;
 		}
-		if (pathname === COHERE_CHAT_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.COHERE_CHAT_PATH && req.method === "POST") {
 			try {
-				await require_cohere.handleCohere(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_cohere.handleCohere(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname, { streamEvent: (m) => `event: error\ndata: ${JSON.stringify({ error: { message: m } })}\n\n` });
 			}
 			return;
 		}
-		if (pathname === COHERE_EMBED_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.COHERE_EMBED_PATH && req.method === "POST") {
 			try {
-				await require_cohere.handleCohereEmbed(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_cohere.handleCohereEmbed(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === EMBEDDINGS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.EMBEDDINGS_PATH && req.method === "POST") {
 			try {
 				const deploymentId = azureDeploymentId;
 				const embeddingsProvider = azureDeploymentId ? "azure" : "openai";
@@ -1875,196 +2675,235 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				} catch (err) {
 					if (!(err instanceof SyntaxError)) defaults.logger.error(`Unexpected error in Azure model injection: ${err instanceof Error ? err.message : String(err)}`);
 				}
-				await require_embeddings.handleEmbeddings(req, res, raw, fixtures, journal, defaults, setCorsHeaders, embeddingsProvider);
+				ensureRawFixturePositions();
+				await require_embeddings.handleEmbeddings(req, res, raw, fixtures, journal, defaults, setCorsHeaders, embeddingsProvider, originalPathname === require_route_registry.EMBEDDINGS_PATH);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === IMAGES_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.IMAGES_PATH && req.method === "POST") {
 			try {
-				await require_images.handleImages(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, "openai", void 0, isBytePlusArk ? "byteplus" : void 0);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_images.handleImages(req, res, raw, fixtures, journal, defaults, setCorsHeaders, "openai", void 0, isBytePlusArk ? "byteplus" : void 0);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === IMAGES_EDIT_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.IMAGES_EDIT_PATH && req.method === "POST") {
 			try {
-				await require_images.handleImageEdit(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_images.handleImageEdit(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === IMAGES_VARIATIONS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.IMAGES_VARIATIONS_PATH && req.method === "POST") {
 			try {
-				await require_images.handleImageVariations(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_images.handleImageVariations(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === SPEECH_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.SPEECH_PATH && req.method === "POST") {
 			try {
-				await require_speech.handleSpeech(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_speech.handleSpeech(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === TRANSCRIPTIONS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.TRANSCRIPTIONS_PATH && req.method === "POST") {
 			try {
-				await require_transcription.handleTranscription(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_transcription.handleTranscription(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === TRANSLATIONS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.TRANSLATIONS_PATH && req.method === "POST") {
 			try {
-				await require_transcription.handleTranscription(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, "translation");
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_transcription.handleTranscription(req, res, raw, fixtures, journal, defaults, setCorsHeaders, "translation");
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === require_metrics.GROK_VIDEO_SUBMIT_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.GROK_VIDEO_SUBMIT_PATH && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_grok_video.handleGrokVideoCreate(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, grokVideoJobs);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_grok_video.handleGrokVideoCreate(req, res, raw, fixtures, journal, defaults, setCorsHeaders, grokVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === VIDEOS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.VIDEOS_PATH && req.method === "POST") {
 			try {
-				await require_video.handleVideoCreate(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, videoStates);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_video.handleVideoCreate(req, res, raw, fixtures, journal, defaults, setCorsHeaders, videoStates);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const grokVideoStatusMatch = pathname.match(require_metrics.GROK_VIDEO_STATUS_RE);
+		const grokVideoStatusMatch = pathname.match(require_route_registry.GROK_VIDEO_STATUS_RE);
 		if (grokVideoStatusMatch && grokVideoStatusMatch[1] !== "generations" && req.method === "GET") {
 			try {
+				ensureRawFixturePositions();
 				await require_grok_video.handleGrokVideoStatus(req, res, grokVideoStatusMatch[1], fixtures, journal, defaults, setCorsHeaders, grokVideoJobs, videoStates);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const veoPredictMatch = pathname.match(require_metrics.VEO_PREDICT_LRO_RE);
+		const veoPredictMatch = pathname.match(require_route_registry.VEO_PREDICT_LRO_RE);
 		if (veoPredictMatch && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_veo_video.handleVeoVideoCreate(req, res, await require_helpers.readBody(req), veoPredictMatch[1], fixtures, journal, defaults, setCorsHeaders, veoVideoJobs);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_veo_video.handleVeoVideoCreate(req, res, raw, veoPredictMatch[1], fixtures, journal, defaults, setCorsHeaders, veoVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const veoOperationMatch = pathname.match(require_metrics.VEO_OPERATION_RE);
+		const veoOperationMatch = pathname.match(require_route_registry.VEO_OPERATION_RE);
 		if (veoOperationMatch && req.method === "GET") {
 			try {
+				ensureRawFixturePositions();
 				await require_veo_video.handleVeoVideoStatus(req, res, veoOperationMatch[1], fixtures, journal, defaults, setCorsHeaders, veoVideoJobs);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const geminiPredictMatch = pathname.match(GEMINI_PREDICT_RE);
+		const geminiPredictMatch = pathname.match(require_route_registry.GEMINI_PREDICT_RE);
 		if (geminiPredictMatch && req.method === "POST") {
 			const predictModel = geminiPredictMatch[1];
 			try {
-				await require_images.handleImages(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders, "gemini", predictModel);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_images.handleImages(req, res, raw, fixtures, journal, defaults, setCorsHeaders, "gemini", predictModel);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === GEMINI_INTERACTIONS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.GEMINI_INTERACTIONS_PATH && req.method === "POST") {
 			try {
-				await require_gemini_interactions.handleGeminiInteractions(req, res, await require_helpers.readBody(req), fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_gemini_interactions.handleGeminiInteractions(req, res, raw, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname, { streamEvent: (m) => `data: ${JSON.stringify({ error: { message: m } })}\n\n` });
 			}
 			return;
 		}
-		const geminiEmbedMatch = pathname.match(GEMINI_EMBED_RE);
+		const geminiEmbedMatch = pathname.match(require_route_registry.GEMINI_EMBED_RE);
 		if (geminiEmbedMatch && req.method === "POST") {
 			const embedModel = geminiEmbedMatch[1];
 			try {
-				await require_gemini_embeddings.handleGeminiEmbedContent(req, res, await require_helpers.readBody(req), embedModel, fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_gemini_embeddings.handleGeminiEmbedContent(req, res, raw, embedModel, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const geminiMatch = pathname.match(GEMINI_PATH_RE);
+		const geminiMatch = pathname.match(require_route_registry.GEMINI_PATH_RE);
 		if (geminiMatch && req.method === "POST") {
 			const geminiModel = geminiMatch[1];
 			const streaming = geminiMatch[2] === "streamGenerateContent";
 			try {
-				await require_gemini.handleGemini(req, res, await require_helpers.readBody(req), geminiModel, streaming, fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_gemini.handleGemini(req, res, raw, geminiModel, streaming, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname, { streamEvent: (m) => `data: ${JSON.stringify({ error: { message: m } })}\n\n` });
 			}
 			return;
 		}
-		const vertexMatch = pathname.match(VERTEX_AI_RE);
+		const vertexMatch = pathname.match(require_route_registry.VERTEX_AI_RE);
 		if (vertexMatch && req.method === "POST") {
 			const vertexModel = vertexMatch[1];
 			const streaming = vertexMatch[2] === "streamGenerateContent";
 			try {
-				await require_gemini.handleGemini(req, res, await require_helpers.readBody(req), vertexModel, streaming, fixtures, journal, defaults, setCorsHeaders, "vertexai");
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_gemini.handleGemini(req, res, raw, vertexModel, streaming, fixtures, journal, defaults, setCorsHeaders, "vertexai");
 			} catch (err) {
 				routeError(req, res, err, pathname, { streamEvent: (m) => `data: ${JSON.stringify({ error: { message: m } })}\n\n` });
 			}
 			return;
 		}
-		const bedrockMatch = pathname.match(BEDROCK_INVOKE_RE);
+		const bedrockMatch = pathname.match(require_route_registry.BEDROCK_INVOKE_RE);
 		if (bedrockMatch && req.method === "POST") {
 			const bedrockModelId = bedrockMatch[1];
 			try {
-				await require_bedrock.handleBedrock(req, res, await require_helpers.readBody(req), bedrockModelId, fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_bedrock.handleBedrock(req, res, raw, bedrockModelId, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const bedrockStreamMatch = pathname.match(BEDROCK_STREAM_RE);
+		const bedrockStreamMatch = pathname.match(require_route_registry.BEDROCK_STREAM_RE);
 		if (bedrockStreamMatch && req.method === "POST") {
 			const bedrockModelId = bedrockStreamMatch[1];
 			try {
-				await require_bedrock.handleBedrockStream(req, res, await require_helpers.readBody(req), bedrockModelId, fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_bedrock.handleBedrockStream(req, res, raw, bedrockModelId, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const converseMatch = pathname.match(BEDROCK_CONVERSE_RE);
+		const converseMatch = pathname.match(require_route_registry.BEDROCK_CONVERSE_RE);
 		if (converseMatch && req.method === "POST") {
 			const converseModelId = converseMatch[1];
 			try {
-				await require_bedrock_converse.handleConverse(req, res, await require_helpers.readBody(req), converseModelId, fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_bedrock_converse.handleConverse(req, res, raw, converseModelId, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const converseStreamMatch = pathname.match(BEDROCK_CONVERSE_STREAM_RE);
+		const converseStreamMatch = pathname.match(require_route_registry.BEDROCK_CONVERSE_STREAM_RE);
 		if (converseStreamMatch && req.method === "POST") {
 			const converseStreamModelId = converseStreamMatch[1];
 			try {
-				await require_bedrock_converse.handleConverseStream(req, res, await require_helpers.readBody(req), converseStreamModelId, fixtures, journal, defaults, setCorsHeaders);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_bedrock_converse.handleConverseStream(req, res, raw, converseStreamModelId, fixtures, journal, defaults, setCorsHeaders);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === SEARCH_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.SEARCH_PATH && req.method === "POST") {
 			try {
 				await require_search.handleSearch(req, res, await require_helpers.readBody(req), serviceFixtures?.search ?? [], journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -2072,7 +2911,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === RERANK_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.RERANK_PATH && req.method === "POST") {
 			try {
 				await require_rerank.handleRerank(req, res, await require_helpers.readBody(req), serviceFixtures?.rerank ?? [], journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -2080,7 +2919,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === MODERATIONS_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.MODERATIONS_PATH && req.method === "POST") {
 			try {
 				await require_moderation.handleModeration(req, res, await require_helpers.readBody(req), serviceFixtures?.moderation ?? [], journal, defaults, setCorsHeaders);
 			} catch (err) {
@@ -2088,34 +2927,40 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			}
 			return;
 		}
-		if (pathname === ELEVENLABS_SOUND_GENERATION_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.ELEVENLABS_SOUND_GENERATION_PATH && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_elevenlabs_audio.handleElevenLabsAudio(req, res, await require_helpers.readBody(req), fixtures, defaults, journal, "sound-generation");
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_elevenlabs_audio.handleElevenLabsAudio(req, res, raw, fixtures, defaults, journal, "sound-generation");
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname === ELEVENLABS_VOICE_DESIGN_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.ELEVENLABS_VOICE_DESIGN_PATH && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_elevenlabs_voice.handleElevenLabsVoiceDesign(req, res, await require_helpers.readBody(req), fixtures, defaults, journal);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_elevenlabs_voice.handleElevenLabsVoiceDesign(req, res, raw, fixtures, defaults, journal);
 			} catch (err) {
 				routeError(req, res, err, pathname, { service: "elevenlabs-voice" });
 			}
 			return;
 		}
-		if (pathname === ELEVENLABS_VOICE_CREATE_PATH && req.method === "POST") {
+		if (pathname === require_route_registry.ELEVENLABS_VOICE_CREATE_PATH && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_elevenlabs_voice.handleElevenLabsVoiceCreate(req, res, await require_helpers.readBody(req), fixtures, defaults, journal);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_elevenlabs_voice.handleElevenLabsVoiceCreate(req, res, raw, fixtures, defaults, journal);
 			} catch (err) {
 				routeError(req, res, err, pathname, { service: "elevenlabs-voice" });
 			}
 			return;
 		}
-		const elevenLabsVoiceMatch = pathname.match(ELEVENLABS_VOICE_RE);
+		const elevenLabsVoiceMatch = pathname.match(require_route_registry.ELEVENLABS_VOICE_RE);
 		if (elevenLabsVoiceMatch && (req.method === "GET" || req.method === "DELETE")) {
 			setCorsHeaders(res);
 			let voiceId;
@@ -2140,37 +2985,46 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				return;
 			}
 			try {
-				if (req.method === "GET") await require_elevenlabs_voice.handleElevenLabsVoiceGet(req, res, voiceId, fixtures, defaults, journal);
-				else await require_elevenlabs_voice.handleElevenLabsVoiceDelete(req, res, voiceId, fixtures, defaults, journal);
+				if (req.method === "GET") {
+					ensureRawFixturePositions();
+					await require_elevenlabs_voice.handleElevenLabsVoiceGet(req, res, voiceId, fixtures, defaults, journal);
+				} else {
+					ensureRawFixturePositions();
+					await require_elevenlabs_voice.handleElevenLabsVoiceDelete(req, res, voiceId, fixtures, defaults, journal);
+				}
 			} catch (err) {
 				routeError(req, res, err, pathname, { service: "elevenlabs-voice" });
 			}
 			return;
 		}
-		const elevenLabsTTSMatch = pathname.match(ELEVENLABS_TTS_RE);
+		const elevenLabsTTSMatch = pathname.match(require_route_registry.ELEVENLABS_TTS_RE);
 		if (elevenLabsTTSMatch && req.method === "POST") {
 			setCorsHeaders(res);
 			const voiceId = elevenLabsTTSMatch[1];
 			try {
-				await require_elevenlabs_audio.handleElevenLabsTTS(req, res, await require_helpers.readBody(req), fixtures, defaults, journal, voiceId);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_elevenlabs_audio.handleElevenLabsTTS(req, res, raw, fixtures, defaults, journal, voiceId);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		const musicMatch = pathname.match(ELEVENLABS_MUSIC_RE);
+		const musicMatch = pathname.match(require_route_registry.ELEVENLABS_MUSIC_RE);
 		if (musicMatch && req.method === "POST") {
 			setCorsHeaders(res);
 			const musicSubType = musicMatch[1] ?? "music";
 			try {
-				await require_elevenlabs_audio.handleElevenLabsAudio(req, res, await require_helpers.readBody(req), fixtures, defaults, journal, musicSubType);
+				const raw = await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_elevenlabs_audio.handleElevenLabsAudio(req, res, raw, fixtures, defaults, journal, musicSubType);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
 		let falBody;
-		if (require_metrics.FAL_ROUTE_RE.test(pathname) && req.headers["x-fal-target-host"]) {
+		if (require_route_registry.FAL_ROUTE_RE.test(pathname) && req.headers["x-fal-target-host"]) {
 			setCorsHeaders(res);
 			try {
 				falBody = req.method === "POST" || req.method === "PUT" ? await require_helpers.readBody(req) : "";
@@ -2194,22 +3048,25 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 						return;
 					}
 				}
+				ensureRawFixturePositions();
 				if (await require_fal.handleFal(req, res, raw, pathname, fixtures, defaults, journal) === "handled") return;
 			} catch (err) {
 				routeError(req, res, err, pathname);
 				return;
 			}
 		}
-		if (pathname.match(FAL_QUEUE_SUBMIT_RE) && req.method === "POST") {
+		if (pathname.match(require_route_registry.FAL_QUEUE_SUBMIT_RE) && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_fal_audio.handleFalQueue(req, res, falBody ?? await require_helpers.readBody(req), pathname, fixtures, defaults, journal);
+				const raw = falBody ?? await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_fal_audio.handleFalQueue(req, res, raw, pathname, fixtures, defaults, journal);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname.match(FAL_QUEUE_REQUESTS_RE) && (req.method === "GET" || req.method === "POST" || req.method === "PUT")) {
+		if (pathname.match(require_route_registry.FAL_QUEUE_REQUESTS_RE) && (req.method === "GET" || req.method === "POST" || req.method === "PUT")) {
 			setCorsHeaders(res);
 			try {
 				const raw = req.method === "POST" || req.method === "PUT" ? falBody ?? await require_helpers.readBody(req) : "{}";
@@ -2230,22 +3087,27 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 					}, "internal", defaults.registry, defaults.logger);
 					return;
 				}
+				ensureRawFixturePositions();
 				await require_fal_audio.handleFalQueue(req, res, raw, pathname, fixtures, defaults, journal);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname.match(FAL_RUN_RE) && req.method === "POST") {
+		if (pathname.match(require_route_registry.FAL_RUN_RE) && req.method === "POST") {
 			setCorsHeaders(res);
 			try {
-				await require_fal_audio.handleFalQueue(req, res, falBody ?? await require_helpers.readBody(req), pathname, fixtures, defaults, journal);
+				const raw = falBody ?? await require_helpers.readBody(req);
+				ensureRawFixturePositions();
+				await require_fal_audio.handleFalQueue(req, res, raw, pathname, fixtures, defaults, journal);
 			} catch (err) {
 				routeError(req, res, err, pathname);
 			}
 			return;
 		}
-		if (pathname !== COMPLETIONS_PATH) {
+		if (pathname !== require_route_registry.COMPLETIONS_PATH) {
+			const catalogMatch = require_route_registry.matchRouteDefinition(req.method ?? "", pathname);
+			if (catalogMatch && !(pathname === require_route_registry.METRICS_PATH && !registry)) defaults.logger.warn(`Route drift: ${req.method ?? "?"} ${pathname} matches the route catalog (${catalogMatch.method} ${catalogMatch.path} — ${catalogMatch.description}) but no dispatcher branch served it. The catalog entry or the dispatcher is stale — see route-registry.ts.`);
 			handleNotFound(res, "Not found");
 			return;
 		}
@@ -2255,13 +3117,14 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 		}
 		const completionsProvider = azureDeploymentId ? "azure" : isOpenRouter ? "openrouter" : isBytePlusArk ? "byteplus" : "openai";
 		try {
-			await handleCompletions(req, res, fixtures, journal, defaults, azureDeploymentId, completionsProvider, isOpenRouter);
+			await handleCompletions(req, res, fixtures, journal, defaults, () => lastJournalEntryFor(req), azureDeploymentId, completionsProvider, isOpenRouter, ensureRawFixturePositions, originalPathname.startsWith("/api/v3/"));
 		} catch (err) {
 			routeError(req, res, err, pathname, {
 				envelope: (m, status) => isOpenRouter ? require_openrouter_chat.serializeOpenRouterError(status, m) : JSON.stringify({ error: {
 					message: m,
 					type: errorTypeForStatus(status)
 				} }),
+				...isOpenRouter ? { toolCallEnvelope: (m, code) => require_openrouter_chat.serializeOpenRouterError(500, m, { reason: code }) } : {},
 				streamEvent: (m, status) => `data: ${isOpenRouter ? require_openrouter_chat.serializeOpenRouterError(status, m) : JSON.stringify({ error: {
 					message: m,
 					type: errorTypeForStatus(status)
@@ -2325,26 +3188,51 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			server.emit("connection", socket);
 			return;
 		}
-		const parsedUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		let parsedUrl;
+		try {
+			parsedUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : "Internal error";
+			defaults.logger.warn(`Unhandled upgrade error: ${msg}`);
+			socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+			return;
+		}
 		let pathname = parsedUrl.pathname;
 		if (!require_api_key_auth.validateRequestApiKey(req, resolvedAuth.policy).ok) {
 			require_api_key_auth.writeApiKeyUpgradeRejection(socket);
 			return;
 		}
-		if (mounts) {
-			for (const { path: mountPath, handler } of mounts) if ((pathname === mountPath || pathname.startsWith(mountPath + "/")) && handler.handleUpgrade) {
-				const subPath = pathname.slice(mountPath.length) || "/";
-				if (await handler.handleUpgrade(socket, head, subPath)) return;
-			}
+		for (const { path: mountPath, handler } of mountList) if ((pathname === mountPath || pathname.startsWith(mountPath + "/")) && handler.handleUpgrade) {
+			const subPath = pathname.slice(mountPath.length) || "/";
+			if (await handler.handleUpgrade(socket, head, subPath)) return;
 		}
-		if (!pathname.match(AZURE_DEPLOYMENT_RE)) pathname = normalizeCompatPath(pathname, logger);
-		if (pathname !== RESPONSES_PATH && pathname !== REALTIME_PATH && pathname !== GEMINI_LIVE_PATH && pathname !== LIVE_PATH) {
+		if (!pathname.match(require_route_registry.AZURE_DEPLOYMENT_RE)) pathname = normalizeCompatPath(pathname, logger);
+		if (pathname !== require_route_registry.RESPONSES_PATH && pathname !== require_route_registry.REALTIME_PATH && pathname !== require_route_registry.GEMINI_LIVE_PATH && pathname !== require_route_registry.LIVE_PATH) {
 			socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
 			socket.destroy();
 			return;
 		}
+		if (defaults.misbehavior && pathname !== require_route_registry.LIVE_PATH && req.headers["x-aimock-misbehavior"] !== void 0) {
+			const code = "aimock_misbehavior_invalid";
+			const message = "use the runtime scope: POST /__aimock/misbehavior with X-Test-Id";
+			const body = JSON.stringify({ error: pathname === require_route_registry.GEMINI_LIVE_PATH ? {
+				code: 400,
+				status: "INVALID_ARGUMENT",
+				message: `${code}: ${message}`
+			} : {
+				type: "invalid_request_error",
+				code,
+				message
+			} });
+			socket.end(`HTTP/1.1 400 Bad Request\r
+Content-Type: application/json\r
+Content-Length: ${Buffer.byteLength(body)}\r\nConnection: close\r
+\r
+` + body);
+			return;
+		}
 		let liveId;
-		if (pathname === LIVE_PATH) {
+		if (pathname === require_route_registry.LIVE_PATH) {
 			if (req.method !== "GET" || parsedUrl.searchParams.has("model")) {
 				socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
 				return;
@@ -2366,7 +3254,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 		if (head.length > 0) socket.unshift(head);
 		let ws;
 		try {
-			ws = require_ws_framing.upgradeToWebSocket(req, socket, pathname === LIVE_PATH ? liveLimits : void 0);
+			ws = require_ws_framing.upgradeToWebSocket(req, socket, pathname === require_route_registry.LIVE_PATH ? liveLimits : void 0);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : "WebSocket upgrade failed";
 			if (liveId !== void 0) liveSessions.delete(liveId);
@@ -2383,7 +3271,7 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 			activeConnections.delete(ws);
 		});
 		const wsTestId = require_helpers.getTestId(req);
-		if (pathname === LIVE_PATH && liveId !== void 0) {
+		if (pathname === require_route_registry.LIVE_PATH && liveId !== void 0) {
 			const sessionId = liveId;
 			const dispose = require_ws_live.handleLiveSession(ws, fixtures, journal, {
 				defaults,
@@ -2400,13 +3288,14 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				testId: wsTestId,
 				dispose
 			});
-		} else if (pathname === RESPONSES_PATH) require_ws_responses.handleWebSocketResponses(ws, fixtures, journal, {
+		} else if (pathname === require_route_registry.RESPONSES_PATH) require_ws_responses.handleWebSocketResponses(ws, fixtures, journal, {
 			...defaults,
 			model: "gpt-4",
 			testId: wsTestId,
-			upgradeHeaders: req.headers
+			upgradeHeaders: req.headers,
+			beforeProcessMessage: ensureRawFixturePositions
 		});
-		else if (pathname === REALTIME_PATH) {
+		else if (pathname === require_route_registry.REALTIME_PATH) {
 			const transcriptionIntent = parsedUrl.searchParams.get("intent") === "transcription";
 			const model = transcriptionIntent ? "gpt-transcribe" : parsedUrl.searchParams.get("model") ?? "gpt-realtime-2";
 			require_ws_realtime.handleWebSocketRealtime(ws, fixtures, journal, {
@@ -2414,13 +3303,15 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				model,
 				transcriptionIntent,
 				testId: wsTestId,
-				upgradeHeaders: req.headers
+				upgradeHeaders: req.headers,
+				beforeProcessMessage: ensureRawFixturePositions
 			});
-		} else if (pathname === GEMINI_LIVE_PATH) require_ws_gemini_live.handleWebSocketGeminiLive(ws, fixtures, journal, {
+		} else if (pathname === require_route_registry.GEMINI_LIVE_PATH) require_ws_gemini_live.handleWebSocketGeminiLive(ws, fixtures, journal, {
 			...defaults,
 			model: "gemini-2.0-flash",
 			testId: wsTestId,
-			upgradeHeaders: req.headers
+			upgradeHeaders: req.headers,
+			beforeProcessMessage: ensureRawFixturePositions
 		});
 	}
 	const originalClose = server.close.bind(server);
@@ -2445,9 +3336,13 @@ async function createServerWithResolvedAuth(fixtures, options, resolvedAuth, mou
 				return;
 			}
 			const url = `http://${addr.address}:${addr.port}`;
-			if (mounts) {
-				for (const { path: mountPath, handler } of mounts) if (handler.setBaseUrl) handler.setBaseUrl(url + mountPath);
+			try {
+				commitHandOff();
+			} catch (err) {
+				server.close(() => reject(err));
+				return;
 			}
+			for (const { path: mountPath, handler } of mountList) if (handler.setBaseUrl) handler.setBaseUrl(url + mountPath);
 			resolve({
 				closeLiveSessions,
 				server,