@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/misbehavior.js

@@ -0,0 +1,1511 @@
+import { assertCustomToolCalls, assertResponsesToolCalls, isCombinedFixtureResponse, isErrorResponse, isTextResponse, isToolCallResponse, keepAuthoredToolArguments, rebuildOrderedBlocks, requireEmittedFunctionToolCalls, resolveFixtureBlocks, resolveServedBlockOutcome, resolveTestId, servedToolCalls, strictToolArgumentsEnabled, toolArgsForWire, toolCallFixtureBlock, withServedToolCalls } from "./helpers.js";
+import { parseChaosNumber } from "./chaos.js";
+
+//#region src/misbehavior.ts
+function normalizeDirectConstraints(schema) {
+	if (!isObject(schema)) return void 0;
+	if (schema.properties !== void 0 && !isObject(schema.properties)) return void 0;
+	if (schema.required !== void 0 && (!Array.isArray(schema.required) || !schema.required.every((name) => typeof name === "string"))) return void 0;
+	if (schema.patternProperties !== void 0 && !isObject(schema.patternProperties)) return void 0;
+	return {
+		properties: schema.properties ?? {},
+		required: schema.required ?? [],
+		...Object.hasOwn(schema, "additionalProperties") ? { additionalProperties: schema.additionalProperties } : {},
+		...schema.patternProperties !== void 0 ? { patternProperties: schema.patternProperties } : {}
+	};
+}
+/**
+* Private tools-only input also permits native Cohere definitions before adaptation.
+* With `scope`, a function tool matches only when its `namespace` equals
+* `scope.namespace` (an absent namespace matches only un-namespaced tools), so
+* an OpenAI Responses call never takes another namespace's same-named schema.
+*/
+function normalizeDirectToolSchema(request, toolName, scope) {
+	for (const tool of request.tools ?? []) {
+		if (!isObject(tool)) continue;
+		if (tool.type === "function" && isObject(tool.function) && tool.function.name === toolName) {
+			if (scope && tool.namespace !== scope.namespace) continue;
+			return normalizeDirectConstraints(tool.function.parameters);
+		}
+		if (tool.name !== toolName || !Object.hasOwn(tool, "parameter_definitions")) continue;
+		const definitions = tool.parameter_definitions;
+		if (!isObject(definitions)) return void 0;
+		const required = [];
+		for (const [name, definition] of Object.entries(definitions)) {
+			if (!isObject(definition)) return void 0;
+			if (definition.required !== void 0 && typeof definition.required !== "boolean") return void 0;
+			if (definition.required === true) required.push(name);
+		}
+		return {
+			properties: definitions,
+			required
+		};
+	}
+}
+/**
+* The schema of a fault's target call. Only OpenAI Responses serves a call's
+* `namespace`, so only there does the lookup resolve (namespace, name).
+*/
+function targetToolSchema(context, target) {
+	return context.wire === "openai-responses" ? normalizeDirectToolSchema(context.request, target.name, { namespace: target.namespace }) : normalizeDirectToolSchema(context.request, target.name);
+}
+function normalizeDirectType(value) {
+	if (typeof value !== "string") return void 0;
+	const type = value.toLowerCase();
+	switch (type) {
+		case "string":
+		case "number":
+		case "integer":
+		case "boolean":
+		case "array":
+		case "object":
+		case "null": return type;
+		default: return;
+	}
+}
+function directPropertyTypes(propertySchema) {
+	if (!isObject(propertySchema)) return void 0;
+	const rawTypes = Array.isArray(propertySchema.type) ? propertySchema.type : [propertySchema.type];
+	if (rawTypes.length === 0) return void 0;
+	const types = [];
+	for (const rawType of rawTypes) {
+		const type = normalizeDirectType(rawType);
+		if (type === void 0) return void 0;
+		types.push(type);
+	}
+	return types;
+}
+function acceptsDirectType(value, type) {
+	switch (type) {
+		case "null": return value === null;
+		case "array": return Array.isArray(value);
+		case "object": return value !== null && typeof value === "object" && !Array.isArray(value);
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "number": return typeof value === "number" && Number.isFinite(value);
+		default: return typeof value === type;
+	}
+}
+function invalidJsonArguments(canonical, style) {
+	let candidate = canonical;
+	if (style === "truncated") candidate = canonical.slice(0, Math.max(1, Math.floor(canonical.length / 2)));
+	else if (style === "trailing-comma" && canonical.endsWith("}")) candidate = `${canonical.slice(0, -1)},}`;
+	else if (style === "single-quotes") candidate = canonical.replace(/\\[\s\S]|"/g, (token) => token === "\"" ? "'" : token);
+	if (candidate === canonical) return void 0;
+	try {
+		JSON.parse(candidate);
+		return;
+	} catch {
+		return candidate;
+	}
+}
+/**
+* The ordered blocks a fault sees. Custom tool calls and namespaces are kept so
+* an OpenAI Responses rewrite serves them unchanged; the planner never reaches
+* here with a custom call on any other wire.
+*/
+function faultBlockOutcome(response) {
+	return isCombinedFixtureResponse(response) ? resolveServedBlockOutcome(response) : void 0;
+}
+/**
+* Index of a tool fault's target: the first function call, or the first one
+* named `tool`. A custom tool call has no JSON arguments, so it is never a
+* fault target; -1 when no function call qualifies.
+*/
+function faultTargetIndex(calls, tool) {
+	return calls.findIndex((call) => call.type !== "custom" && (tool === void 0 || call.name === tool));
+}
+/** The function call at `index`, or undefined when absent or custom. */
+function functionCallAt(calls, index) {
+	const call = calls[index];
+	return call !== void 0 && call.type !== "custom" ? call : void 0;
+}
+/** Replace a response's tool calls one-for-one, rebuilding ordered blocks when present. */
+function rewriteFaultToolCalls(response, outcome, toolCalls) {
+	if (!outcome) return withServedToolCalls(response, toolCalls);
+	return withServedToolCalls({
+		...response,
+		content: outcome.content
+	}, toolCalls, rebuildOrderedBlocks(outcome.ordered, toolCalls));
+}
+/** Prepare K1 without selecting a fault, spending counters, or mutating input. */
+function prepareInvalidJsonCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	const canonical = args.kind === "parsed" ? args.text : args.raw;
+	const style = fault.style ?? MISBEHAVIOR_CATALOG[fault.fault].defaults.style;
+	const argumentsText = invalidJsonArguments(canonical, style);
+	if (argumentsText === void 0) return {
+		kind: "not-applicable",
+		detail: `${style} cannot produce changed invalid JSON`
+	};
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+				...call,
+				arguments: argumentsText
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: style
+		}
+	};
+}
+/** Prepare K2 missing-required without selecting a fault or spending counters. */
+function prepareMissingRequiredCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	if (args.kind !== "parsed" || !isObject(args.value)) return {
+		kind: "not-applicable",
+		detail: "Arguments must parse to an object"
+	};
+	const value = args.value;
+	const schema = targetToolSchema(context, target);
+	if (!schema) return {
+		kind: "not-applicable",
+		detail: "Target tool has no direct schema"
+	};
+	const property = fault.property ?? schema.required.find((name) => Object.hasOwn(value, name));
+	if (property === void 0 || !schema.required.includes(property) || !Object.hasOwn(value, property)) return {
+		kind: "not-applicable",
+		detail: "No present required property can be removed"
+	};
+	const copied = { ...value };
+	delete copied[property];
+	const argumentsText = JSON.stringify(copied);
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+				...call,
+				arguments: argumentsText
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: "missing-required"
+		}
+	};
+}
+function wrongTypeReplacement(type) {
+	switch (type) {
+		case "string":
+		case "null": return 12345;
+		case "number":
+		case "integer": return "not-a-number";
+		case "boolean": return "true";
+		case "array": return {};
+		case "object": return "[object]";
+	}
+}
+/** Prepare K2 wrong-type without selecting a fault or spending counters. */
+function prepareWrongTypeCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	if (args.kind !== "parsed" || !isObject(args.value)) return {
+		kind: "not-applicable",
+		detail: "Arguments must parse to an object"
+	};
+	const value = args.value;
+	const schema = targetToolSchema(context, target);
+	if (!schema) return {
+		kind: "not-applicable",
+		detail: "Target tool has no direct schema"
+	};
+	const names = fault.property === void 0 ? Object.keys(schema.properties) : [fault.property];
+	let mutation;
+	for (const property of names) {
+		if (!Object.hasOwn(value, property) || !Object.hasOwn(schema.properties, property)) continue;
+		const propertySchema = schema.properties[property];
+		const types = directPropertyTypes(propertySchema);
+		if (!types) continue;
+		const replacement = (!(isObject(propertySchema) && Array.isArray(propertySchema.type)) ? [wrongTypeReplacement(types[0])] : [
+			12345,
+			"not-a-number",
+			"true",
+			{},
+			"[object]",
+			null
+		]).find((candidate) => types.every((type) => !acceptsDirectType(candidate, type)));
+		if (replacement === void 0 || JSON.stringify(replacement) === JSON.stringify(value[property])) continue;
+		mutation = {
+			property,
+			replacement
+		};
+		break;
+	}
+	if (!mutation) return {
+		kind: "not-applicable",
+		detail: "No present declared property has a provably wrong replacement"
+	};
+	const argumentsText = JSON.stringify({
+		...value,
+		[mutation.property]: mutation.replacement
+	});
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+				...call,
+				arguments: argumentsText
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: "wrong-type"
+		}
+	};
+}
+/** Prepare K2 extra-property only when direct constraints prove the addition invalid. */
+function prepareExtraPropertyCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	if (args.kind !== "parsed" || !isObject(args.value)) return {
+		kind: "not-applicable",
+		detail: "Arguments must parse to an object"
+	};
+	const value = args.value;
+	const schema = targetToolSchema(context, target);
+	if (!schema || schema.additionalProperties !== false) return {
+		kind: "not-applicable",
+		detail: "Target schema does not forbid additional properties"
+	};
+	const property = fault.property ?? "__aimock_extra";
+	if (Object.hasOwn(schema.properties, property) || Object.hasOwn(value, property)) return {
+		kind: "not-applicable",
+		detail: "Extra property name is already declared or present"
+	};
+	for (const [pattern, patternSchema] of Object.entries(schema.patternProperties ?? {})) try {
+		if (new RegExp(pattern).test(property) && patternSchema !== false) return {
+			kind: "not-applicable",
+			detail: "A pattern covers the extra property name"
+		};
+	} catch {
+		return {
+			kind: "not-applicable",
+			detail: "A property pattern cannot be evaluated"
+		};
+	}
+	const argumentsText = JSON.stringify({
+		...value,
+		[property]: true
+	});
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+				...call,
+				arguments: argumentsText
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: "extra-property"
+		}
+	};
+}
+/** Prepare K2 enum-mismatch without selecting a fault or spending counters. */
+function prepareEnumMismatchCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	if (args.kind !== "parsed" || !isObject(args.value)) return {
+		kind: "not-applicable",
+		detail: "Arguments must parse to an object"
+	};
+	const value = args.value;
+	const schema = targetToolSchema(context, target);
+	if (!schema) return {
+		kind: "not-applicable",
+		detail: "Target tool has no direct schema"
+	};
+	const names = fault.property === void 0 ? Object.keys(schema.properties) : [fault.property];
+	let mutation;
+	for (const property of names) {
+		if (!Object.hasOwn(value, property) || !Object.hasOwn(schema.properties, property)) continue;
+		const propertySchema = schema.properties[property];
+		if (!isObject(propertySchema) || !Array.isArray(propertySchema.enum)) continue;
+		let replacement = "__aimock_not_in_enum";
+		let suffix = 2;
+		while (propertySchema.enum.includes(replacement)) replacement = `__aimock_not_in_enum_${suffix++}`;
+		if (replacement === value[property]) continue;
+		mutation = {
+			property,
+			replacement
+		};
+		break;
+	}
+	if (!mutation) return {
+		kind: "not-applicable",
+		detail: "No present declared enum property has a changed out-of-enum replacement"
+	};
+	const argumentsText = JSON.stringify({
+		...value,
+		[mutation.property]: mutation.replacement
+	});
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+				...call,
+				arguments: argumentsText
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: "enum-mismatch"
+		}
+	};
+}
+/** Prepare K2 not-object without selecting a fault or spending counters. */
+function prepareNotObjectCandidate(context, fault) {
+	if (!supportsMisbehavior(context.wire, {
+		...fault,
+		violation: "not-object"
+	}, context.stream)) return {
+		kind: "not-applicable",
+		detail: "not-object is unsupported on this wire/output mode"
+	};
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	if (args.kind !== "parsed" || !isObject(args.value)) return {
+		kind: "not-applicable",
+		detail: "Arguments must parse to an object"
+	};
+	const argumentsText = JSON.stringify(args.text);
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+				...call,
+				arguments: argumentsText
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: "not-object"
+		}
+	};
+}
+const fixtureMisbehaviorPositions = /* @__PURE__ */ new WeakMap();
+function setFixtureMisbehaviorPosition(fixture, position) {
+	fixtureMisbehaviorPositions.set(fixture, position);
+}
+function getFixtureMisbehaviorPosition(fixture) {
+	return fixtureMisbehaviorPositions.get(fixture);
+}
+function copyFixtureMisbehaviorPosition(from, to) {
+	const position = getFixtureMisbehaviorPosition(from);
+	if (position !== void 0) setFixtureMisbehaviorPosition(to, position);
+}
+/** Shared by fixture identity and the seeded planner; hash UTF-8 bytes, not UTF-16 units. */
+function fnv1a32(text) {
+	let hash = 2166136261;
+	for (const byte of new TextEncoder().encode(text)) hash = Math.imul(hash ^ byte, 16777619);
+	return hash >>> 0;
+}
+/** Canonicalize the declared match/config domain without shortening strings or arrays. */
+function canonicalIdentityValue(value) {
+	if (value instanceof RegExp) return { $regexp: value.toString() };
+	if (typeof value === "function") return "fn";
+	if (Array.isArray(value)) return value.map(canonicalIdentityValue);
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, canonicalIdentityValue(child)]));
+	return value;
+}
+/** Ingress must assign a logical load/addition position before planning a fixture fault. */
+function fixtureMisbehaviorSourceKey(fixture, config) {
+	const position = getFixtureMisbehaviorPosition(fixture);
+	if (!position) throw new Error("Missing fixture misbehavior position: internal invariant");
+	const canonicalMatch = JSON.stringify(canonicalIdentityValue(fixture.match));
+	const seedlessConfig = Object.fromEntries(Object.entries(config).filter(([key]) => key !== "seed"));
+	return `fixture:${fnv1a32(`${canonicalMatch}|${JSON.stringify(canonicalIdentityValue(seedlessConfig))}|${position}`)}`;
+}
+const string = (value) => typeof value === "string";
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const choices = (...values) => (value) => typeof value === "string" && values.includes(value);
+/** Single catalog for accepted parameters and their defaults. Defaults are applied by the planner. */
+const MISBEHAVIOR_CATALOG = {
+	"tool-args-invalid-json": {
+		parameters: { style: choices("truncated", "trailing-comma", "single-quotes") },
+		defaults: { style: "truncated" }
+	},
+	"tool-args-schema-violation": {
+		parameters: {
+			violation: choices("missing-required", "wrong-type", "extra-property", "enum-mismatch", "not-object"),
+			property: string
+		},
+		defaults: { violation: "missing-required" }
+	},
+	"tool-unknown-name": {
+		parameters: { name: string },
+		defaults: {}
+	},
+	"tool-call-id-duplicate": {
+		parameters: {},
+		defaults: {}
+	},
+	"stop-length-mid-tool": {
+		parameters: { at: (v) => typeof v === "number" && finite(v) && v > 0 && v < 1 },
+		defaults: { at: .5 }
+	},
+	"empty-response": {
+		parameters: {},
+		defaults: {}
+	},
+	refusal: {
+		parameters: {
+			message: string,
+			category: (v) => v === null || string(v)
+		},
+		defaults: {
+			message: "I can't help with that.",
+			category: null
+		}
+	},
+	"content-filter": {
+		parameters: {},
+		defaults: {}
+	},
+	"reasoning-only": {
+		parameters: { reasoning: string },
+		defaults: {}
+	}
+};
+/** Engine stage: all nine faults are supported only on OpenAI Chat. */
+const WIRE_SUPPORT = {
+	"openai-chat": {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "yes",
+			"content-filter": "yes",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: true,
+			nonstream: true
+		}
+	},
+	"openai-responses": {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "yes",
+			"content-filter": "yes",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: true,
+			nonstream: true
+		}
+	},
+	"openai-realtime": {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "yes",
+			"reasoning-only": "n/a"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: true,
+			nonstream: true
+		}
+	},
+	anthropic: {
+		faults: {
+			"tool-args-invalid-json": "stream-only",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "yes",
+			"content-filter": "n/a",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: true,
+		notObject: {
+			stream: true,
+			nonstream: false
+		}
+	},
+	"bedrock-invoke": {
+		faults: {
+			"tool-args-invalid-json": "stream-only",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "yes",
+			"content-filter": "n/a",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: true,
+		notObject: {
+			stream: true,
+			nonstream: false
+		}
+	},
+	"bedrock-converse": {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "yes",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: true,
+			nonstream: false
+		}
+	},
+	gemini: {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "yes",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: false,
+			nonstream: false
+		}
+	},
+	"gemini-live": {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "n/a",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "n/a",
+			"reasoning-only": "n/a"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: false,
+			nonstream: false
+		}
+	},
+	"gemini-interactions": {
+		faults: {
+			"tool-args-invalid-json": "stream-only",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "n/a",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: true,
+			nonstream: false
+		}
+	},
+	cohere: {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "yes",
+			"stop-length-mid-tool": "yes",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "n/a",
+			"reasoning-only": "n/a"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: true,
+			nonstream: true
+		}
+	},
+	ollama: {
+		faults: {
+			"tool-args-invalid-json": "yes",
+			"tool-args-schema-violation": "yes",
+			"tool-unknown-name": "yes",
+			"tool-call-id-duplicate": "n/a",
+			"stop-length-mid-tool": "n/a",
+			"empty-response": "yes",
+			refusal: "n/a",
+			"content-filter": "n/a",
+			"reasoning-only": "yes"
+		},
+		refusalCategory: false,
+		notObject: {
+			stream: false,
+			nonstream: false
+		}
+	}
+};
+function supportsMisbehavior(wire, fault, stream) {
+	if (!isWireId(wire)) return false;
+	const support = WIRE_SUPPORT[wire];
+	const mode = stream ? "stream" : "nonstream";
+	const base = support.faults[fault.fault];
+	if (base === "n/a" || base === "stream-only" && !stream) return false;
+	if (fault.fault === "refusal" && Object.hasOwn(fault, "category") && !support.refusalCategory) return false;
+	return fault.fault !== "tool-args-schema-violation" || fault.violation !== "not-object" || support.notObject[mode];
+}
+function isWireId(value) {
+	return typeof value === "string" && Object.hasOwn(WIRE_SUPPORT, value);
+}
+function isFaultId(value) {
+	return typeof value === "string" && Object.hasOwn(MISBEHAVIOR_CATALOG, value);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+/** Error reporting must not invoke user-authored primitive conversion hooks. */
+function describeInvalidValue(value) {
+	try {
+		const text = JSON.stringify(value) ?? typeof value;
+		return text.length > 200 ? `${text.slice(0, 200)}…` : text;
+	} catch {
+		return "[unserializable value]";
+	}
+}
+function failure(rule, path, value) {
+	return {
+		ok: false,
+		issue: {
+			rule,
+			path,
+			value,
+			message: `${rule} at ${path}: invalid value ${describeInvalidValue(value)}`
+		}
+	};
+}
+const common = {
+	rate: (v) => parseChaosNumber(v, 1) !== void 0,
+	times: (v) => typeof v === "number" && Number.isInteger(v) && v > 0,
+	tool: string,
+	providers: (v) => Array.isArray(v)
+};
+/** Strict object/shorthand parser; wire applicability is evaluated after scope/provider selection. */
+function parseMisbehavior(input, path = "misbehavior") {
+	if (typeof input === "string") return isFaultId(input) ? {
+		ok: true,
+		config: { faults: [{ fault: input }] }
+	} : failure("misbehavior/bad-value", path, input);
+	if (!isObject(input)) return failure("misbehavior/bad-value", path, input);
+	for (const key of Object.keys(input)) if (key !== "seed" && key !== "faults") return failure("misbehavior/unknown-key", `${path}.${key}`, input[key]);
+	if (Object.hasOwn(input, "seed") && input.seed !== "random" && !(typeof input.seed === "number" && Number.isInteger(input.seed))) return failure("misbehavior/bad-value", `${path}.seed`, input.seed);
+	if (!Array.isArray(input.faults)) return failure("misbehavior/bad-value", `${path}.faults`, input.faults);
+	const faults = [];
+	for (let index = 0; index < input.faults.length; index++) {
+		const entry = input.faults[index];
+		const entryPath = `${path}.faults[${index}]`;
+		if (!isObject(entry)) return failure("misbehavior/bad-value", entryPath, entry);
+		if (!isFaultId(entry.fault)) return failure("misbehavior/bad-value", `${entryPath}.fault`, entry.fault);
+		const parameters = MISBEHAVIOR_CATALOG[entry.fault].parameters;
+		for (const key of Object.keys(entry)) {
+			if (key === "fault") continue;
+			const check = Object.hasOwn(common, key) ? common[key] : Object.hasOwn(parameters, key) ? parameters[key] : void 0;
+			if (!check) return failure("misbehavior/unknown-key", `${entryPath}.${key}`, entry[key]);
+			if (!check(entry[key])) return failure("misbehavior/bad-value", `${entryPath}.${key}`, entry[key]);
+		}
+		if (Array.isArray(entry.providers)) {
+			for (let i = 0; i < entry.providers.length; i++) if (!isWireId(entry.providers[i])) return failure("misbehavior/bad-value", `${entryPath}.providers[${i}]`, entry.providers[i]);
+		}
+		faults.push({
+			...entry,
+			...Object.hasOwn(entry, "rate") ? { rate: parseChaosNumber(entry.rate, 1) } : {},
+			...Array.isArray(entry.providers) ? { providers: [...entry.providers] } : {}
+		});
+	}
+	return {
+		ok: true,
+		config: {
+			...typeof input.seed === "number" || input.seed === "random" ? { seed: input.seed } : {},
+			faults
+		}
+	};
+}
+/**
+* One fault followed by semicolon-delimited scalar key=value pairs. Values are
+* literal text: the first equals sign separates the key, with no unquoting.
+* Node's repeated-header comma joining must still parse as one whole grammar.
+*/
+function parseMisbehaviorHeader(value) {
+	if (value === void 0) return void 0;
+	const path = "headers.x-aimock-misbehavior";
+	const [fault, ...pairs] = (Array.isArray(value) ? value.join(", ") : value).split(";").map((part) => part.trim());
+	if (!isFaultId(fault)) return failure("misbehavior/bad-value", path, value);
+	const entry = { fault };
+	for (const pair of pairs) {
+		const separator = pair.indexOf("=");
+		const key = pair.slice(0, separator).trim();
+		if (separator < 0 || !key) return failure("misbehavior/bad-value", path, pair);
+		const fieldPath = `${path}.faults[0].${key}`;
+		if (key === "fault" || key === "times" || key === "providers") return failure("misbehavior/unknown-key", fieldPath, pair);
+		if (Object.hasOwn(entry, key)) return failure("misbehavior/bad-value", fieldPath, pair);
+		const scalar = pair.slice(separator + 1).trim();
+		const parsed = key === "at" ? parseChaosNumber(scalar, 1) ?? scalar : scalar;
+		Object.defineProperty(entry, key, {
+			value: parsed,
+			enumerable: true
+		});
+	}
+	return parseMisbehavior({ faults: [entry] }, path);
+}
+/** Only statically decidable S3/S4 checks; no factories or request schemas are evaluated. */
+function validateFixtureMisbehavior(fixture, path = "misbehavior") {
+	if (fixture.misbehavior === void 0) return void 0;
+	const parsed = parseMisbehavior(fixture.misbehavior, path);
+	if (!parsed.ok) return parsed.issue;
+	const endpoint = fixture.match.endpoint;
+	const wires = Object.keys(WIRE_SUPPORT).filter(isWireId).filter((wire) => endpoint === "realtime" ? wire === "openai-realtime" : endpoint === "chat" ? wire !== "openai-realtime" : true);
+	const nonchat = endpoint !== void 0 && endpoint !== "chat" && endpoint !== "realtime";
+	const response = fixture.response;
+	for (const [index, fault] of parsed.config.faults.entries()) {
+		const possible = wires.filter((wire) => fault.providers === void 0 || fault.providers.includes(wire));
+		if (possible.length === 0) continue;
+		let reason;
+		if (nonchat) reason = "misbehavior/not-applicable";
+		else if (typeof response !== "function") {
+			const combined = isCombinedFixtureResponse(response);
+			if (isErrorResponse(response) || !(combined || isTextResponse(response) || isToolCallResponse(response))) reason = "misbehavior/not-applicable";
+			else {
+				const calls = (combined ? resolveServedBlockOutcome(response)?.toolCalls : void 0) ?? ("toolCalls" in response ? servedToolCalls(response) : []);
+				const toolFault = fault.fault.startsWith("tool-") || fault.fault === "stop-length-mid-tool";
+				const target = toolFault ? functionCallAt(calls, faultTargetIndex(calls, fault.tool)) : void 0;
+				if (toolFault && !target) reason = "misbehavior/not-applicable";
+				else if (fault.tool !== void 0 && !calls.some((call) => call.name === fault.tool && call.type !== "custom")) reason = "misbehavior/not-applicable";
+				else if (target) {
+					const args = toolArgsForWire(target);
+					const canonical = args.kind === "parsed" ? args.text : args.raw;
+					if (fault.fault === "tool-args-schema-violation") if (args.kind !== "parsed" || args.value === null || typeof args.value !== "object" || Array.isArray(args.value)) reason = "misbehavior/not-applicable";
+					else {
+						const violation = fault.violation ?? MISBEHAVIOR_CATALOG[fault.fault].defaults.violation;
+						if (violation === "extra-property") {
+							if (Object.hasOwn(args.value, fault.property ?? "__aimock_extra")) reason = "misbehavior/not-applicable";
+						} else if (violation !== "not-object") {
+							if (!(fault.property === void 0 ? Object.keys(args.value).length > 0 : Object.hasOwn(args.value, fault.property))) reason = "misbehavior/not-applicable";
+						}
+					}
+					else if (fault.fault === "stop-length-mid-tool") {
+						if (Math.max(1, Math.floor(canonical.length * (fault.at ?? MISBEHAVIOR_CATALOG[fault.fault].defaults.at))) >= canonical.length) reason = "misbehavior/not-applicable";
+					} else if (fault.fault === "tool-args-invalid-json") {
+						if (invalidJsonArguments(canonical, fault.style ?? MISBEHAVIOR_CATALOG[fault.fault].defaults.style) === void 0) reason = "misbehavior/not-applicable";
+					}
+				}
+			}
+		}
+		if (!reason && !possible.some((wire) => supportsMisbehavior(wire, fault, false) || supportsMisbehavior(wire, fault, true))) reason = "misbehavior/unsupported-on-wire";
+		if (reason) {
+			const entryPath = `${path}.faults[${index}]`;
+			return {
+				rule: reason,
+				path: entryPath,
+				value: fault,
+				message: `${reason} at ${entryPath}: ${fault.fault} cannot apply to this fixture`
+			};
+		}
+	}
+}
+/** Prepare K3 without selecting a fault, spending counters, or mutating input. */
+function prepareUnknownNameCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const inScope = (tool) => context.wire !== "openai-responses" || tool.namespace === target.namespace;
+	const declared = new Set((context.request.tools ?? []).filter(inScope).map((tool) => tool.function.name));
+	let name = fault.name ?? `${target.name}_v2`;
+	if (fault.name !== void 0 && declared.has(name)) return {
+		kind: "not-applicable",
+		detail: "Explicit replacement tool name is declared in the request"
+	};
+	if (fault.name === void 0) {
+		const base = name;
+		for (let suffix = 2; declared.has(name); suffix++) name = `${base}_${suffix}`;
+	}
+	if (name === target.name) return {
+		kind: "not-applicable",
+		detail: "Replacement tool name is unchanged"
+	};
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewriteFaultToolCalls(response, outcome, calls.map((call, callIndex) => callIndex === index ? {
+				...call,
+				name
+			} : { ...call })),
+			target: {
+				tool: target.name,
+				index
+			},
+			detail: name
+		}
+	};
+}
+/** Prepare shared identity without allocating the renderer's opaque call IDs. */
+function prepareDuplicateIdCandidate(context, fault) {
+	if (context.toolCallIdMode !== "authored-nonempty" && typeof context.emitsToolCallIds !== "boolean") throw new TypeError("K4 preparation requires the selected output mode's emitsToolCallIds capability");
+	if (context.toolCallIdMode === void 0 && !context.emitsToolCallIds) return {
+		kind: "not-applicable",
+		detail: "Current output mode does not emit tool call IDs"
+	};
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const sourceIndex = faultTargetIndex(calls, fault.tool);
+	const source = functionCallAt(calls, sourceIndex);
+	if (!source) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	if (context.toolCallIdMode === "authored-nonempty") {
+		const emitsToolCallIds = Boolean(source.id);
+		if (context.emitsToolCallIds !== void 0 && context.emitsToolCallIds !== emitsToolCallIds) throw new Error("Conflicting current output ID capabilities: internal invariant");
+		if (!emitsToolCallIds) return {
+			kind: "not-applicable",
+			detail: "Current output mode does not emit target tool call ID"
+		};
+	}
+	let destinationIndex = -1;
+	for (let step = 1; step < calls.length && destinationIndex === -1; step++) if (functionCallAt(calls, (sourceIndex + step) % calls.length)) destinationIndex = (sourceIndex + step) % calls.length;
+	const inserted = destinationIndex === -1;
+	const toolCalls = calls.map((call) => ({ ...call }));
+	if (inserted) {
+		destinationIndex = sourceIndex + 1;
+		toolCalls.splice(destinationIndex, 0, { ...source });
+	}
+	if (source.id === void 0) delete toolCalls[destinationIndex].id;
+	else toolCalls[destinationIndex].id = source.id;
+	let rewritten = withServedToolCalls(response, toolCalls);
+	if (outcome) {
+		let callIndex = 0;
+		const blocks = outcome.ordered.flatMap((block) => {
+			if (block.type === "text") return [{ ...block }];
+			const isSource = callIndex === sourceIndex;
+			const rewrittenBlock = toolCallFixtureBlock(toolCalls[callIndex++]);
+			if (!(inserted && isSource)) return [rewrittenBlock];
+			return [rewrittenBlock, toolCallFixtureBlock(toolCalls[callIndex++])];
+		});
+		rewritten = withServedToolCalls({
+			...response,
+			content: outcome.content
+		}, toolCalls, blocks);
+	}
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewritten,
+			target: {
+				tool: source.name,
+				index: sourceIndex
+			},
+			duplicateId: {
+				sourceIndex,
+				destinationIndex
+			}
+		}
+	};
+}
+/** Prepare a strict argument prefix without selecting a fault or spending counters. */
+function prepareLengthCandidate(context, fault) {
+	const response = context.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (isErrorResponse(response) || !(combined || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response has no tool calls"
+	};
+	const outcome = faultBlockOutcome(response);
+	const calls = outcome?.toolCalls ?? servedToolCalls(response);
+	const index = faultTargetIndex(calls, fault.tool);
+	const target = functionCallAt(calls, index);
+	if (!target) return {
+		kind: "not-applicable",
+		detail: "Target tool call is absent"
+	};
+	const args = toolArgsForWire(target);
+	const canonical = args.kind === "parsed" ? args.text : args.raw;
+	const at = fault.at ?? MISBEHAVIOR_CATALOG[fault.fault].defaults.at;
+	const cut = Math.max(1, Math.floor(canonical.length * at));
+	if (canonical.length < 2 || !(cut < canonical.length)) return {
+		kind: "not-applicable",
+		detail: "Arguments have no strict nonempty proper prefix"
+	};
+	const toolCalls = calls.slice(0, index + 1).map((call, callIndex) => callIndex === index && call.type !== "custom" ? {
+		...call,
+		arguments: canonical.slice(0, cut)
+	} : { ...call });
+	let rewritten = withServedToolCalls(response, toolCalls);
+	if (outcome) {
+		const blocks = [];
+		let callIndex = 0;
+		let content = "";
+		for (const block of outcome.ordered) if (block.type === "text") {
+			content += block.text;
+			blocks.push({ ...block });
+		} else {
+			blocks.push(toolCallFixtureBlock(toolCalls[callIndex]));
+			if (callIndex++ === index) break;
+		}
+		rewritten = withServedToolCalls({
+			...response,
+			content
+		}, toolCalls, blocks);
+	}
+	return {
+		kind: "ready",
+		candidate: {
+			response: rewritten,
+			stop: "length",
+			target: {
+				tool: target.name,
+				index
+			}
+		}
+	};
+}
+/** Remove all chat output channels while preserving response metadata. */
+function clearChatOutput(response) {
+	const cleared = {
+		...response,
+		content: ""
+	};
+	delete cleared.blocks;
+	delete cleared.responsesBlocks;
+	delete cleared.toolCalls;
+	delete cleared.customToolCalls;
+	delete cleared.reasoning;
+	delete cleared.reasoningSignature;
+	delete cleared.redactedThinking;
+	delete cleared.webSearches;
+	delete cleared.finishReason;
+	delete cleared.nativeFinishReason;
+	return cleared;
+}
+/** Prepare an empty normal completion without mutating the resolved response. */
+function prepareEmptyCandidate(context, fault) {
+	const response = context.response;
+	if (isErrorResponse(response) || !(isCombinedFixtureResponse(response) || isTextResponse(response) || isToolCallResponse(response))) return {
+		kind: "not-applicable",
+		detail: "Response is not a chat response"
+	};
+	if (fault.tool !== void 0) {
+		const calls = (isCombinedFixtureResponse(response) ? resolveServedBlockOutcome(response)?.toolCalls : void 0) ?? ("toolCalls" in response ? servedToolCalls(response) : []);
+		if (!calls.some((call) => call.name === fault.tool && call.type !== "custom")) return {
+			kind: "not-applicable",
+			detail: calls.some((call) => call.name === fault.tool) ? "Target tool call is a custom tool call" : "Target tool call is absent"
+		};
+	}
+	return {
+		kind: "ready",
+		candidate: {
+			response: clearChatOutput(response),
+			stop: "stop"
+		}
+	};
+}
+/** Prepare structured refusal data; the planner checks support on the original fault. */
+function prepareRefusalCandidate(context, fault) {
+	const empty = prepareEmptyCandidate(context, {
+		fault: "empty-response",
+		tool: fault.tool
+	});
+	if (empty.kind !== "ready") return empty;
+	return {
+		kind: "ready",
+		candidate: {
+			response: empty.candidate.response,
+			stop: "refusal",
+			refusal: fault.message ?? MISBEHAVIOR_CATALOG.refusal.defaults.message,
+			refusalCategory: fault.category ?? MISBEHAVIOR_CATALOG.refusal.defaults.category
+		}
+	};
+}
+/** Prepare withheld output; the planner checks support on the original fault. */
+function prepareContentFilterCandidate(context, fault) {
+	const empty = prepareEmptyCandidate(context, {
+		fault: "empty-response",
+		tool: fault.tool
+	});
+	if (empty.kind !== "ready") return empty;
+	return {
+		kind: "ready",
+		candidate: {
+			response: empty.candidate.response,
+			stop: "content_filter"
+		}
+	};
+}
+/** Prepare reasoning-only output; the planner checks support on the original fault. */
+function prepareReasoningOnlyCandidate(context, fault) {
+	const empty = prepareEmptyCandidate(context, {
+		fault: "empty-response",
+		tool: fault.tool
+	});
+	if (empty.kind !== "ready") return empty;
+	const fixtureReasoning = "reasoning" in context.response ? context.response.reasoning : void 0;
+	return {
+		kind: "ready",
+		candidate: {
+			response: empty.candidate.response,
+			stop: "length",
+			reasoning: fault.reasoning ?? fixtureReasoning ?? "Thinking..."
+		}
+	};
+}
+/** Dispatch only after the planner has checked authored parameter/wire support. */
+function prepareMisbehaviorCandidate(context, fault) {
+	switch (fault.fault) {
+		case "tool-args-invalid-json": return prepareInvalidJsonCandidate(context, fault);
+		case "tool-args-schema-violation": {
+			const violation = fault.violation ?? "missing-required";
+			switch (violation) {
+				case "missing-required": return prepareMissingRequiredCandidate(context, fault);
+				case "wrong-type": return prepareWrongTypeCandidate(context, fault);
+				case "extra-property": return prepareExtraPropertyCandidate(context, fault);
+				case "enum-mismatch": return prepareEnumMismatchCandidate(context, fault);
+				case "not-object": return prepareNotObjectCandidate(context, fault);
+				default: return assertUnreachableMisbehavior(violation);
+			}
+		}
+		case "tool-unknown-name": return prepareUnknownNameCandidate(context, fault);
+		case "tool-call-id-duplicate": {
+			if (context.toolCallIdMode === "authored-nonempty") return prepareDuplicateIdCandidate({
+				...context,
+				toolCallIdMode: context.toolCallIdMode
+			}, fault);
+			const emitsToolCallIds = context.wire === "openai-chat" ? true : context.emitsToolCallIds;
+			if (emitsToolCallIds === void 0) throw new Error("Missing current output ID capability: internal invariant");
+			return prepareDuplicateIdCandidate({
+				...context,
+				emitsToolCallIds
+			}, fault);
+		}
+		case "stop-length-mid-tool": return prepareLengthCandidate(context, fault);
+		case "empty-response": return prepareEmptyCandidate(context, fault);
+		case "refusal": return prepareRefusalCandidate(context, fault);
+		case "content-filter": return prepareContentFilterCandidate(context, fault);
+		case "reasoning-only": return prepareReasoningOnlyCandidate(context, fault);
+		default: return assertUnreachableMisbehavior(fault);
+	}
+}
+function assertUnreachableMisbehavior(value) {
+	throw new Error(`Unknown misbehavior candidate: ${String(value)}`);
+}
+let processMisbehaviorSeed;
+/** Shared with config inspection so a random run can be replayed with this numeric seed. */
+function resolveMisbehaviorSeed(seed, logger) {
+	if (seed !== "random") return seed ?? 0;
+	if (processMisbehaviorSeed === void 0) {
+		processMisbehaviorSeed = Math.floor(Math.random() * 4294967296);
+		logger.info(`Misbehavior random seed: ${processMisbehaviorSeed}`);
+	}
+	return processMisbehaviorSeed;
+}
+function misbehaviorRoll(seed) {
+	let value = seed + 1831565813;
+	value = Math.imul(value ^ value >>> 15, value | 1);
+	value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+	return ((value ^ value >>> 14) >>> 0) / 4294967296;
+}
+/**
+* Whether the wire's normal path would serve this response's blocks and tool
+* calls, or reject the fixture. Mirrors that path: non-empty ordered `blocks`
+* are authoritative (the legacy `toolCalls` is then never read), only the
+* OpenAI Responses API may carry a custom tool call, and every entry must be
+* well formed. A wire that carries arguments as an object also rejects a
+* function call whose `arguments` are not valid JSON (see
+* {@link rejectsInvalidToolArguments}). A rejection is either a coded fixture
+* tool-call error or the plain Error for a malformed text block or an unknown
+* block type; all of them mean the wire cannot serve the fixture.
+*/
+function servesFixture(wire, stream, response) {
+	if (typeof response !== "object" || response === null) return true;
+	const blocks = "blocks" in response ? response.blocks : void 0;
+	let functionCalls = [];
+	try {
+		if (wire === "openai-responses") {
+			if (!resolveServedBlockOutcome(response) && "toolCalls" in response) {
+				assertCustomToolCalls(response);
+				assertResponsesToolCalls(servedToolCalls(response));
+			}
+		} else if ("toolCalls" in response || "blocks" in response || "responsesBlocks" in response) {
+			functionCalls = requireEmittedFunctionToolCalls(response, wire);
+			if (Array.isArray(blocks) && blocks.length > 0) functionCalls = resolveFixtureBlocks(blocks).filter((block) => block.type === "toolCall");
+		}
+	} catch {
+		return false;
+	}
+	return !(strictToolArgumentsEnabled() ? rejectsInvalidToolArguments(wire, stream) : replacesInvalidToolArguments(wire)) || functionCalls.every((call) => toolArgsForWire(call).kind === "parsed");
+}
+/**
+* Whether the normal path of this wire serves invalid-JSON `arguments` as
+* `{}` / `"{}"` (the default, as in 1.44.0) instead of the authored text. The
+* OpenAI wires pass the authored text through unchanged.
+*/
+function replacesInvalidToolArguments(wire) {
+	return rejectsInvalidToolArguments(wire, false) || wire === "cohere";
+}
+/**
+* Whether this wire and output mode carry tool arguments as an object, so the
+* normal path must parse a fixture's string `arguments` and, under
+* `strictToolArguments`, answers aimock_invalid_tool_arguments when they are
+* not valid JSON. The other modes
+* pass the authored string through unchanged (the OpenAI wires, Cohere, and
+* the streaming Anthropic, Bedrock and Gemini Interactions paths, which send
+* arguments as a JSON-string fragment).
+*/
+function rejectsInvalidToolArguments(wire, stream) {
+	switch (wire) {
+		case "gemini":
+		case "gemini-live":
+		case "ollama": return true;
+		case "anthropic":
+		case "bedrock-invoke":
+		case "bedrock-converse":
+		case "gemini-interactions": return !stream;
+		default: return false;
+	}
+}
+/** Complete preparation precedes selection; every candidate sees the original response. */
+function planMisbehavior(input) {
+	const { wire, fixture, defaults } = input;
+	if (!defaults.misbehavior) return { kind: "skipped" };
+	const testId = resolveTestId(input.rawHeaders, input.url);
+	let source;
+	let parsed = parseMisbehaviorHeader(input.rawHeaders["x-aimock-misbehavior"]);
+	if (parsed !== void 0) source = "header";
+	else if (fixture.misbehavior !== void 0) {
+		source = "fixture";
+		parsed = parseMisbehavior(fixture.misbehavior);
+	} else if (defaults.misbehavior?.byTestId.has(testId)) {
+		source = "scope";
+		parsed = parseMisbehavior(defaults.misbehavior.byTestId.get(testId));
+	} else if (defaults.misbehavior?.baseline !== void 0) {
+		source = "server";
+		parsed = parseMisbehavior(defaults.misbehavior.baseline);
+	} else return { kind: "skipped" };
+	if (!parsed.ok) return {
+		kind: "error",
+		status: source === "header" ? 400 : 501,
+		code: source === "header" ? "aimock_misbehavior_invalid" : "aimock_misbehavior_not_applicable",
+		message: `${wire}: ${parsed.issue.message}`,
+		summary: {
+			applied: false,
+			source,
+			wire,
+			evaluations: []
+		}
+	};
+	if (!servesFixture(wire, input.stream, input.response)) return { kind: "skipped" };
+	const config = parsed.config;
+	const explicit = source === "header" || source === "fixture";
+	const evaluations = [];
+	const candidates = /* @__PURE__ */ new Map();
+	const details = /* @__PURE__ */ new Map();
+	const summaryFor = (row) => ({
+		applied: row?.outcome === "applied",
+		source,
+		wire,
+		evaluations: [...evaluations].sort((a, b) => a.entryIndex - b.entryIndex),
+		...row ? {
+			fault: row.fault,
+			...row.reason !== void 0 ? { reason: row.reason } : {},
+			...row.ordinal !== void 0 ? { ordinal: row.ordinal } : {},
+			...details.has(row.entryIndex) ? { detail: details.get(row.entryIndex) } : {}
+		} : { reason: "disabled" }
+	});
+	for (const [entryIndex, fault] of config.faults.entries()) {
+		if (fault.providers !== void 0 && !fault.providers.includes(wire)) {
+			evaluations.push({
+				entryIndex,
+				fault: fault.fault,
+				outcome: "skipped",
+				reason: "provider-excluded"
+			});
+			continue;
+		}
+		let reason;
+		let detail;
+		const response = input.response;
+		const combined = isCombinedFixtureResponse(response);
+		if (isErrorResponse(response) || !(combined || isTextResponse(response) || isToolCallResponse(response))) {
+			reason = "not-applicable";
+			detail = "Response is not a chat response";
+		} else if (input.faultRenderingAvailable === false || !supportsMisbehavior(wire, fault, input.stream)) {
+			reason = "unsupported-on-wire";
+			detail = "Fault or authored parameter is unsupported in this wire/output mode";
+		} else {
+			const prepared = prepareMisbehaviorCandidate(input, fault);
+			if (prepared.kind === "ready") candidates.set(entryIndex, prepared.candidate);
+			else {
+				reason = "not-applicable";
+				detail = prepared.detail;
+			}
+		}
+		if (reason) {
+			if (detail !== void 0) details.set(entryIndex, detail);
+			const row = {
+				entryIndex,
+				fault: fault.fault,
+				outcome: explicit ? "error" : "skipped",
+				reason
+			};
+			evaluations.push(row);
+			if (explicit) return {
+				kind: "error",
+				status: 501,
+				code: reason === "unsupported-on-wire" ? "aimock_misbehavior_unsupported" : "aimock_misbehavior_not_applicable",
+				message: `${fault.fault} on ${wire}: ${reason}: ${detail}`,
+				summary: summaryFor(row)
+			};
+		}
+	}
+	if (candidates.size > 0) {
+		const counters = defaults.misbehaviorCounters;
+		if (!counters) throw new Error("Missing misbehavior journal counters: internal invariant");
+		const sourceKey = source === "fixture" ? fixtureMisbehaviorSourceKey(fixture, config) : source === "scope" ? `scope:${testId}` : source;
+		const seed = resolveMisbehaviorSeed(config.seed, defaults.logger);
+		for (const [entryIndex, candidate] of candidates) {
+			const fault = config.faults[entryIndex];
+			const key = {
+				testId,
+				sourceKey,
+				entryIndex
+			};
+			if (fault.times !== void 0 && counters.getFiringCount(key) >= fault.times) {
+				evaluations.push({
+					entryIndex,
+					fault: fault.fault,
+					outcome: "skipped",
+					reason: "times-exhausted"
+				});
+				continue;
+			}
+			const ordinal = counters.nextOrdinal(key);
+			if (misbehaviorRoll(fnv1a32(`${seed}|${testId}|${sourceKey}|${entryIndex}|${ordinal}`)) >= (fault.rate ?? 1)) {
+				evaluations.push({
+					entryIndex,
+					fault: fault.fault,
+					outcome: "skipped",
+					reason: "not-rolled",
+					ordinal
+				});
+				continue;
+			}
+			counters.recordFiring(key);
+			const row = {
+				entryIndex,
+				fault: fault.fault,
+				outcome: "applied",
+				ordinal
+			};
+			evaluations.push(row);
+			keepAuthoredToolArguments();
+			return {
+				kind: "applied",
+				...candidate,
+				summary: {
+					...summaryFor(row),
+					...candidate.target !== void 0 ? { target: candidate.target } : {},
+					...candidate.detail !== void 0 ? { detail: candidate.detail } : {}
+				}
+			};
+		}
+	}
+	return {
+		kind: "skipped",
+		summary: summaryFor([...evaluations].sort((a, b) => a.entryIndex - b.entryIndex).at(-1))
+	};
+}
+const recordedMisbehaviorEntries = /* @__PURE__ */ new WeakSet();
+const warnedUnsupportedMisbehavior = /* @__PURE__ */ new WeakMap();
+/** Record prepared output on the existing request; this is not a delivery receipt. */
+function recordMisbehaviorOutcome({ entry, summary, defaults, testId }) {
+	if (!summary || recordedMisbehaviorEntries.has(entry)) return;
+	if (summary.applied && !Array.isArray(summary.servedToolCalls)) throw new Error("Applied misbehavior requires prepared servedToolCalls before journaling");
+	if (summary.evaluations.length > 0 && summary.wire === void 0) throw new Error("Misbehavior evaluations require a wire before journaling");
+	entry.response.misbehavior = summary;
+	recordedMisbehaviorEntries.add(entry);
+	for (const evaluation of summary.evaluations) {
+		if (summary.wire === void 0) continue;
+		const outcome = evaluation.reason ? `${evaluation.outcome}:${evaluation.reason}` : evaluation.outcome;
+		defaults.registry?.incrementCounter("aimock_misbehavior_total", {
+			fault: evaluation.fault,
+			wire: summary.wire,
+			outcome
+		});
+		const message = `[misbehavior] ${evaluation.fault} ${outcome} on ${summary.wire} (testId=${testId})`;
+		if (evaluation.outcome === "error") defaults.logger.error(message);
+		else if (evaluation.outcome === "applied") defaults.logger.info(message);
+		else if (evaluation.reason === "unsupported-on-wire") {
+			let warned = warnedUnsupportedMisbehavior.get(defaults.logger);
+			if (!warned) {
+				warned = /* @__PURE__ */ new Set();
+				warnedUnsupportedMisbehavior.set(defaults.logger, warned);
+			}
+			const key = JSON.stringify([
+				testId,
+				evaluation.fault,
+				summary.wire
+			]);
+			if (!warned.has(key)) {
+				warned.add(key);
+				defaults.logger.warn(message);
+			}
+		} else defaults.logger.debug(message);
+	}
+}
+/** Resolve configuration presence only; request boundaries validate headers before bypassing. */
+function resolveMisbehaviorShortCircuit(input) {
+	const { wire, fixture, defaults, rawHeaders, url, reason } = input;
+	if (!defaults.misbehavior) return void 0;
+	const testId = resolveTestId(rawHeaders, url);
+	let source;
+	if (rawHeaders["x-aimock-misbehavior"] !== void 0) source = "header";
+	else if (fixture?.misbehavior !== void 0) source = "fixture";
+	else if (defaults.misbehavior?.byTestId.has(testId)) source = "scope";
+	else if (defaults.misbehavior?.baseline !== void 0) source = "server";
+	else return void 0;
+	return {
+		applied: false,
+		source,
+		wire,
+		reason,
+		evaluations: []
+	};
+}
+
+//#endregion
+export { MISBEHAVIOR_CATALOG, WIRE_SUPPORT, copyFixtureMisbehaviorPosition, getFixtureMisbehaviorPosition, normalizeDirectToolSchema, parseMisbehavior, parseMisbehaviorHeader, planMisbehavior, recordMisbehaviorOutcome, resolveMisbehaviorSeed, resolveMisbehaviorShortCircuit, setFixtureMisbehaviorPosition, validateFixtureMisbehavior };
+//# sourceMappingURL=misbehavior.js.map