@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/responses.cjs

@@ -1,10 +1,13 @@
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_model_utils = require('./model-utils.cjs');
 const require_helpers = require('./helpers.cjs');
 const require_sse_writer = require('./sse-writer.cjs');
 const require_chaos = require('./chaos.cjs');
+const require_misbehavior = require('./misbehavior.cjs');
 const require_router = require('./router.cjs');
 const require_recorder = require('./recorder.cjs');
 const require_interruption = require('./interruption.cjs');
+let node_crypto = require("node:crypto");
 
 //#region src/responses.ts
 function extractTextContent(content) {
@@ -12,7 +15,36 @@ function extractTextContent(content) {
 	if (typeof content === "string") return content;
 	return content.filter((p) => p.type === "input_text" || p.type === "output_text").map((p) => p.text ?? "").join("");
 }
-function responsesInputToMessages(req) {
+/**
+* A `custom_tool_call_output.output` is a string or a list of content parts
+* (`input_text` / `input_image` / `input_file`). Flatten a list to its
+* concatenated `input_text` text so text matchers such as
+* `toolResultContains` see it.
+*
+* The value comes straight from the request body, so it is read as `unknown`.
+* Like `function_call_output`, a malformed output never fails the request:
+* any other value (null, an object, a number) yields empty text, and list
+* entries that are not `input_text` parts with string text are skipped.
+*/
+function customToolOutputText(output) {
+	if (typeof output === "string") return output;
+	if (!Array.isArray(output)) return "";
+	return output.map((p) => {
+		if (p === null || typeof p !== "object") return "";
+		const part = p;
+		return part.type === "input_text" && typeof part.text === "string" ? part.text : "";
+	}).join("");
+}
+/**
+* Convert Responses input items into chat messages for fixture matching. The
+* default is the conversion of earlier releases: `custom_tool_call` and
+* `custom_tool_call_output` items are skipped, and history namespaces are not
+* kept. With `extended`, a custom tool call becomes an assistant message with
+* `custom_tool_calls` (so turn counting sees it), its output becomes a `tool`
+* message (so `hasToolResult` and `toolCallId` see it), and a `function_call`
+* keeps its `namespace`.
+*/
+function responsesInputToMessages(req, extended = false) {
 	const messages = [];
 	const itemReferencePlaceholders = /* @__PURE__ */ new WeakSet();
 	if (req.instructions) messages.push({
@@ -26,6 +58,25 @@ function responsesInputToMessages(req) {
 		});
 		return messages;
 	}
+	/** A synthesized call for an output item that has no matching call. */
+	const attachSynthesizedCall = (target, item) => {
+		const id = item.call_id ?? require_helpers.generateToolCallId();
+		if (item.type === "custom_tool_call_output") (target.custom_tool_calls ??= []).push({
+			id,
+			type: "custom",
+			name: "",
+			input: ""
+		});
+		else (target.tool_calls ??= []).push({
+			id,
+			type: "function",
+			function: {
+				name: "",
+				arguments: ""
+			}
+		});
+	};
+	const hasCalls = (m) => m.tool_calls !== void 0 || m.custom_tool_calls !== void 0;
 	for (const item of req.input) if (item.role === "system" || item.role === "developer") messages.push({
 		role: "system",
 		content: extractTextContent(item.content)
@@ -44,61 +95,55 @@ function responsesInputToMessages(req) {
 		tool_calls: [{
 			id: item.call_id ?? require_helpers.generateToolCallId(),
 			type: "function",
+			...extended && typeof item.namespace === "string" ? { namespace: item.namespace } : {},
 			function: {
 				name: item.name ?? "",
 				arguments: item.arguments ?? ""
 			}
 		}]
 	});
-	else if (item.type === "function_call_output") {
-		if (!messages.some((m) => m.role === "assistant" && m.tool_calls?.some((tc) => tc.id === item.call_id))) {
+	else if (extended && item.type === "custom_tool_call") messages.push({
+		role: "assistant",
+		content: null,
+		custom_tool_calls: [{
+			id: item.call_id ?? require_helpers.generateToolCallId(),
+			type: "custom",
+			name: item.name ?? "",
+			input: typeof item.input === "string" ? item.input : "",
+			...typeof item.namespace === "string" ? { namespace: item.namespace } : {}
+		}]
+	});
+	else if (item.type === "function_call_output" || extended && item.type === "custom_tool_call_output") {
+		if (!messages.some((m) => m.role === "assistant" && (m.tool_calls?.some((tc) => tc.id === item.call_id) || m.custom_tool_calls?.some((tc) => tc.id === item.call_id)))) {
 			const lastMsg = messages[messages.length - 1];
-			if (lastMsg && lastMsg.role === "assistant" && itemReferencePlaceholders.has(lastMsg) && !lastMsg.tool_calls) {
+			if (lastMsg && lastMsg.role === "assistant" && itemReferencePlaceholders.has(lastMsg) && !hasCalls(lastMsg)) {
 				lastMsg.content = null;
-				lastMsg.tool_calls = [{
-					id: item.call_id ?? require_helpers.generateToolCallId(),
-					type: "function",
-					function: {
-						name: "",
-						arguments: ""
-					}
-				}];
+				attachSynthesizedCall(lastMsg, item);
 				itemReferencePlaceholders.delete(lastMsg);
 			} else {
 				let appended = false;
 				for (let k = messages.length - 1; k >= 0; k--) {
 					const m = messages[k];
-					if (m.role === "assistant" && m.tool_calls) {
-						m.tool_calls.push({
-							id: item.call_id ?? require_helpers.generateToolCallId(),
-							type: "function",
-							function: {
-								name: "",
-								arguments: ""
-							}
-						});
+					if (m.role === "assistant" && hasCalls(m)) {
+						attachSynthesizedCall(m, item);
 						appended = true;
 						break;
 					}
 					if (m.role === "user") break;
 				}
-				if (!appended) messages.push({
-					role: "assistant",
-					content: null,
-					tool_calls: [{
-						id: item.call_id ?? require_helpers.generateToolCallId(),
-						type: "function",
-						function: {
-							name: "",
-							arguments: ""
-						}
-					}]
-				});
+				if (!appended) {
+					const synthesized = {
+						role: "assistant",
+						content: null
+					};
+					attachSynthesizedCall(synthesized, item);
+					messages.push(synthesized);
+				}
 			}
 		}
 		messages.push({
 			role: "tool",
-			content: item.output ?? "",
+			content: item.type === "custom_tool_call_output" ? customToolOutputText(item.output) : item.output ?? "",
 			tool_call_id: item.call_id
 		});
 	} else if (item.type === "item_reference") {
@@ -111,6 +156,7 @@ function responsesInputToMessages(req) {
 	}
 	return messages;
 }
+/** The request tools of earlier releases: top-level `function` tools only. */
 function responsesToolsToCompletionsTools(tools) {
 	if (!tools || tools.length === 0) return void 0;
 	return tools.filter((t) => t.type === "function").map((t) => ({
@@ -122,17 +168,146 @@ function responsesToolsToCompletionsTools(tools) {
 		}
 	}));
 }
-function responsesToCompletionRequest(req) {
+/** One Responses `function` or `custom` tool in aimock's normalized form. */
+function normalizeResponsesTool(tool, namespace) {
+	if (tool === null || typeof tool !== "object") return void 0;
+	const t = tool;
+	const ns = namespace !== void 0 ? { namespace } : {};
+	if (t.type === "function") {
+		const fn = t;
+		return {
+			type: "function",
+			...ns,
+			function: {
+				name: fn.name,
+				description: fn.description,
+				parameters: fn.parameters
+			}
+		};
+	}
+	if (t.type === "custom") {
+		const custom = t;
+		return {
+			type: "custom",
+			name: custom.name,
+			...custom.description !== void 0 ? { description: custom.description } : {},
+			...ns,
+			...custom.format !== void 0 ? { format: custom.format } : {}
+		};
+	}
+}
+/**
+* Input items whose `tools` add to the request's tools:
+* `additional_tools` (Codex responses-lite) and `tool_search_output` (tools
+* loaded by tool search, e.g. Codex's deferred MCP namespaces). Both carry the
+* same function / custom / namespace tool shapes as `req.tools`.
+*/
+function isToolCarryingItemType(type) {
+	return type === "additional_tools" || type === "tool_search_output";
+}
+/**
+* Why a `namespace` tool cannot be flattened, or undefined when it can: its
+* name is not a non-empty string (OpenAI's `NamespaceToolParam` requires
+* `name` with `minLength: 1`), or its `tools` is not an array.
+*/
+function namespaceToolProblem(tool) {
+	if (typeof tool.name !== "string" || tool.name === "") return "name is not a non-empty string";
+	if (!Array.isArray(tool.tools)) return "tools is not an array";
+}
+/**
+* Flatten every Responses tool a request offers, for extended matching and for
+* `toolNamespace`. Sources, in order: `req.tools`, then the `tools` of every
+* `additional_tools` or `tool_search_output` input item, in input order.
+* `namespace` tools contribute one entry per inner function/custom tool, each
+* carrying the namespace; other tool types are ignored.
+*
+* Malformed items never fail the request (earlier releases ignored them): a
+* `namespace` tool without a non-empty string name or with a non-array
+* `tools`, a `null` entry, and a tool-carrying item whose `tools` is not an
+* array are dropped, with a warning when `warn` is given.
+*/
+function flattenResponsesTools(req, warn) {
+	const tools = [];
+	const customTools = [];
+	const add = (normalized) => {
+		if (!normalized) return;
+		if (normalized.type === "custom") customTools.push(normalized);
+		else tools.push(normalized);
+	};
+	const sources = [];
+	if (Array.isArray(req.tools)) req.tools.forEach((tool, i) => sources.push({
+		tool,
+		path: `tools[${i}]`
+	}));
+	if (Array.isArray(req.input)) req.input.forEach((item, i) => {
+		if (!isToolCarryingItemType(item?.type) || item?.tools === void 0) return;
+		if (!Array.isArray(item.tools)) {
+			warn?.(`Ignoring input[${i}].tools: not an array`);
+			return;
+		}
+		item.tools.forEach((tool, j) => sources.push({
+			tool,
+			path: `input[${i}].tools[${j}]`
+		}));
+	});
+	for (const { tool, path } of sources) {
+		const t = tool;
+		if (t === null) {
+			warn?.(`Ignoring ${path}: null tool`);
+			continue;
+		}
+		if (t?.type === "namespace") {
+			const problem = namespaceToolProblem(t);
+			if (problem) {
+				warn?.(`Ignoring namespace tool ${path}: ${problem}`);
+				continue;
+			}
+			t.tools.forEach((inner, k) => {
+				if (inner === null) warn?.(`Ignoring ${path}.tools[${k}]: null tool`);
+				else add(normalizeResponsesTool(inner, t.name));
+			});
+			continue;
+		}
+		add(normalizeResponsesTool(tool));
+	}
 	return {
+		tools,
+		customTools,
+		sourceCount: sources.length
+	};
+}
+function responsesToCompletionRequest(req, options = {}) {
+	const extended = options.extended === true;
+	const all = flattenResponsesTools(req, extended && options.logger ? (message) => options.logger?.warn(`Responses request: ${message}`) : void 0);
+	const completionReq = {
 		model: req.model,
-		messages: responsesInputToMessages(req),
+		messages: responsesInputToMessages(req, extended),
 		stream: req.stream,
 		temperature: req.temperature,
 		max_tokens: req.max_output_tokens,
-		tools: responsesToolsToCompletionsTools(req.tools),
+		tools: extended ? all.sourceCount > 0 ? all.tools : void 0 : responsesToolsToCompletionsTools(req.tools),
+		...extended && all.customTools.length > 0 ? { customTools: all.customTools } : {},
 		tool_choice: req.tool_choice,
 		response_format: req.response_format
 	};
+	require_router.setResponsesOfferedTools(completionReq, {
+		tools: all.tools,
+		customTools: all.customTools
+	});
+	return completionReq;
+}
+/**
+* The HTTP request check of earlier releases for `tools`: keep the
+* converter's empty/falsy bypass, and reject only a collection the legacy
+* converter would throw on (not an array, or a `null` entry). Malformed
+* nested tools (inside a `namespace` tool or a tool-carrying input item) are
+* dropped by the conversion instead.
+*/
+function validateResponsesTools(tools) {
+	if (tools && tools.length !== 0) {
+		if (!Array.isArray(tools)) return "tools must be an array";
+		if (tools.some((tool) => tool === null)) return "tools entries must not be null";
+	}
 }
 function responsesStatus(finishReason, defaultStatus) {
 	if (!finishReason) return defaultStatus;
@@ -180,56 +355,105 @@ function buildTextStreamEvents(content, model, chunkSize, reasoning, webSearches
 	});
 	return events;
 }
+function requireFixtureToolArguments(value) {
+	if (typeof value !== "string") throw new Error("Invalid fixture tool call: \"arguments\" must be a string after normalization");
+	return value;
+}
+function requireFixtureToolInput(value) {
+	if (typeof value !== "string") throw new Error("Invalid fixture tool call: \"input\" must be a string for a custom tool call");
+	return value;
+}
+function isCustomEmittable(call) {
+	if (call === null || typeof call !== "object") return false;
+	return call.type === "custom" || call.type === "customToolCall";
+}
+/**
+* A Responses `function_call` item. `namespace` is added only when the fixture
+* sets it, so a call without one keeps the keys and key order it had before
+* namespaces existed (existing fixtures stay byte-identical on the wire).
+*/
+function functionCallItem(call, fcId, callId, args, status) {
+	return {
+		type: "function_call",
+		id: fcId,
+		call_id: callId,
+		...call.namespace !== void 0 ? { namespace: call.namespace } : {},
+		name: call.name,
+		arguments: args,
+		status
+	};
+}
+/**
+* `ctc_…` item id, the prefix the OpenAI guide and Codex's item-id map use for
+* custom tool calls. The underscore separator is deliberate: it matches the
+* real id format, so this does not use `generateId` (which would give
+* `ctc-…`, like aimock's own `fc-…` ids).
+*/
+function customToolCallItemId() {
+	return `ctc_${(0, node_crypto.randomBytes)(12).toString("base64url")}`;
+}
+/** A Responses `custom_tool_call` item; `namespace` is added only when set. */
+function customToolCallItem(call, ctcId, callId, input, status) {
+	return {
+		type: "custom_tool_call",
+		id: ctcId,
+		call_id: callId,
+		...call.namespace !== void 0 ? { namespace: call.namespace } : {},
+		name: call.name,
+		input,
+		status
+	};
+}
+/**
+* A `toolCalls` entry as earlier releases served it: a function call whose
+* `type`, `input` and `namespace` are ignored. The exported builders take
+* fixtures in that form; the handler passes `namespace` (extended mode) and
+* custom calls to the internal builders instead.
+*/
+function legacyFunctionCall(call) {
+	if (call === null || typeof call !== "object") return call;
+	const { name, arguments: args, id } = call;
+	return id !== void 0 ? {
+		name,
+		arguments: args,
+		id
+	} : {
+		name,
+		arguments: args
+	};
+}
+/**
+* The exported builders' `toolCalls` as legacy function calls. It walks
+* `toolCalls` by index up to `toolCalls.length`, as earlier releases did, so an
+* untyped caller's non-array value gives the same calls: none for an object
+* without `length`, and entries by index for a string or array-like.
+*/
+function legacyFunctionCalls(toolCalls) {
+	const calls = [];
+	for (let idx = 0; idx < toolCalls.length; idx++) calls.push(legacyFunctionCall(toolCalls[idx]));
+	return calls;
+}
+/** Resolve exported-builder `blocks` as earlier releases did (no namespace emitted). */
+function legacyOrderedBlocks(blocks) {
+	if (!blocks || blocks.length === 0) return void 0;
+	return require_helpers.resolveFixtureBlocks(blocks).map((block) => {
+		if (block.type === "text" || block.namespace === void 0) return block;
+		const copy = { ...block };
+		delete copy.namespace;
+		return copy;
+	});
+}
 function buildToolCallStreamEvents(toolCalls, model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	return toolCallStreamEvents(legacyFunctionCalls(toolCalls), model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
+}
+function toolCallStreamEvents(toolCalls, model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	require_helpers.assertResponsesToolCalls(toolCalls);
 	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 	const fcOutputItems = [];
 	for (let idx = 0; idx < toolCalls.length; idx++) {
-		const tc = toolCalls[idx];
-		const callId = tc.id || require_helpers.generateToolCallId();
-		const fcId = require_helpers.generateId("fc");
-		const outputIndex = nextOutputIndex + idx;
-		events.push({
-			type: "response.output_item.added",
-			output_index: outputIndex,
-			item: {
-				type: "function_call",
-				id: fcId,
-				call_id: callId,
-				name: tc.name,
-				arguments: "",
-				status: "in_progress"
-			}
-		});
-		const args = tc.arguments;
-		for (let i = 0; i < args.length; i += chunkSize) {
-			const slice = args.slice(i, i + chunkSize);
-			events.push({
-				type: "response.function_call_arguments.delta",
-				item_id: fcId,
-				output_index: outputIndex,
-				delta: slice
-			});
-		}
-		events.push({
-			type: "response.function_call_arguments.done",
-			item_id: fcId,
-			output_index: outputIndex,
-			arguments: args
-		});
-		const doneItem = {
-			type: "function_call",
-			id: fcId,
-			call_id: callId,
-			name: tc.name,
-			arguments: args,
-			status: "completed"
-		};
-		events.push({
-			type: "response.output_item.done",
-			output_index: outputIndex,
-			item: doneItem
-		});
-		fcOutputItems.push(doneItem);
+		const { events: callEvents, item } = buildToolCallOutputEvents(toolCalls[idx], chunkSize, nextOutputIndex + idx);
+		events.push(...callEvents);
+		fcOutputItems.push(item);
 	}
 	events.push({
 		type: "response.completed",
@@ -460,7 +684,7 @@ function buildWebSearchStreamEvents(queries, startOutputIndex) {
 	}
 	return events;
 }
-function buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+function buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false, forceReasoning = false) {
 	const respId = overrides?.id ?? responseId();
 	const created = overrides?.created ?? Math.floor(Date.now() / 1e3);
 	const effectiveModel = overrides?.model ?? model;
@@ -489,7 +713,7 @@ function buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrid
 			output: []
 		}
 	});
-	if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) {
+	if (reasoning || forceReasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) {
 		const reasoningEvents = buildReasoningStreamEvents(reasoning, chunkSize, emitEncryptedReasoning);
 		events.push(...reasoningEvents);
 		const doneEvent = reasoningEvents.find((e) => e.type === "response.output_item.done" && e.item?.type === "reasoning");
@@ -585,27 +809,20 @@ function buildMessageOutputEvents(content, chunkSize, outputIndex) {
 /**
 * Emit the output_item.added → arguments deltas → arguments.done →
 * output_item.done events for a single function_call at `outputIndex`,
-* returning the completed item for the final `output` array. Behavior is
-* identical to the inline per-tool-call loop in the legacy path; both the
-* legacy branch and the ordered-blocks branch share this so wire output stays
-* byte-identical for a given (tool, outputIndex).
+* returning the completed item for the final `output` array. Every Responses
+* streaming builder (tool-only, legacy content+toolCalls and ordered blocks)
+* reaches this through {@link buildToolCallOutputEvents}, so a given
+* (tool, outputIndex) has the same wire output on every path.
 */
 function buildFunctionCallOutputEvents(toolCall, chunkSize, outputIndex) {
 	const callId = toolCall.id || require_helpers.generateToolCallId();
 	const fcId = require_helpers.generateId("fc");
-	const args = toolCall.arguments;
+	const args = requireFixtureToolArguments(toolCall.arguments);
 	const events = [];
 	events.push({
 		type: "response.output_item.added",
 		output_index: outputIndex,
-		item: {
-			type: "function_call",
-			id: fcId,
-			call_id: callId,
-			name: toolCall.name,
-			arguments: "",
-			status: "in_progress"
-		}
+		item: functionCallItem(toolCall, fcId, callId, "", "in_progress")
 	});
 	for (let i = 0; i < args.length; i += chunkSize) events.push({
 		type: "response.function_call_arguments.delta",
@@ -619,24 +836,78 @@ function buildFunctionCallOutputEvents(toolCall, chunkSize, outputIndex) {
 		output_index: outputIndex,
 		arguments: args
 	});
-	const fcItem = {
-		type: "function_call",
-		id: fcId,
-		call_id: callId,
-		name: toolCall.name,
-		arguments: args,
-		status: "completed"
+	const item = functionCallItem(toolCall, fcId, callId, args, "completed");
+	events.push({
+		type: "response.output_item.done",
+		output_index: outputIndex,
+		item
+	});
+	return {
+		events,
+		item
 	};
+}
+/**
+* `text` cut into slices of at most `chunkSize` UTF-16 units, never between
+* the two halves of a surrogate pair: a cut that would land inside a pair
+* moves back before it, or, when that would leave the slice empty
+* (`chunkSize` 1), forward past it. The slices rejoin to `text` exactly.
+*/
+function surrogateSafeChunks(text, chunkSize) {
+	const chunks = [];
+	for (let i = 0; i < text.length;) {
+		let end = Math.min(i + chunkSize, text.length);
+		const high = text.charCodeAt(end - 1);
+		const low = text.charCodeAt(end);
+		if (high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343) end = end - 1 > i ? end - 1 : end + 1;
+		chunks.push(text.slice(i, end));
+		i = end;
+	}
+	return chunks;
+}
+/**
+* Emit output_item.added → custom_tool_call_input.delta×N →
+* custom_tool_call_input.done → output_item.done for one `custom_tool_call` at
+* `outputIndex`, returning the completed item. An empty `input`
+* yields no delta event.
+*/
+function buildCustomToolCallOutputEvents(call, chunkSize, outputIndex) {
+	const callId = call.id || require_helpers.generateToolCallId();
+	const ctcId = customToolCallItemId();
+	const input = requireFixtureToolInput(call.input);
+	const events = [];
+	events.push({
+		type: "response.output_item.added",
+		output_index: outputIndex,
+		item: customToolCallItem(call, ctcId, callId, "", "in_progress")
+	});
+	for (const delta of surrogateSafeChunks(input, chunkSize)) events.push({
+		type: "response.custom_tool_call_input.delta",
+		item_id: ctcId,
+		output_index: outputIndex,
+		delta
+	});
+	events.push({
+		type: "response.custom_tool_call_input.done",
+		item_id: ctcId,
+		output_index: outputIndex,
+		input
+	});
+	const item = customToolCallItem(call, ctcId, callId, input, "completed");
 	events.push({
 		type: "response.output_item.done",
 		output_index: outputIndex,
-		item: fcItem
+		item
 	});
 	return {
 		events,
-		fcItem
+		item
 	};
 }
+/** Streaming dispatcher: one function or custom tool call at `outputIndex`. */
+function buildToolCallOutputEvents(call, chunkSize, outputIndex) {
+	return isCustomEmittable(call) ? buildCustomToolCallOutputEvents(call, chunkSize, outputIndex) : buildFunctionCallOutputEvents(call, chunkSize, outputIndex);
+}
 function buildOutputPrefix(content, model, reasoning, webSearches, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
 	const output = [];
 	if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) output.push(buildReasoningOutputItem(require_helpers.generateId("rs"), {
@@ -680,6 +951,7 @@ function buildTextResponse(content, model, reasoning, webSearches, overrides, em
 	return buildResponseEnvelope(model, buildOutputPrefix(content, model, reasoning, webSearches, emitEncryptedReasoning, synthesizeSummarylessReasoning), overrides);
 }
 function buildToolCallResponse(toolCalls, model, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	require_helpers.assertResponsesToolCalls(toolCalls);
 	const output = [];
 	if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) output.push(buildReasoningOutputItem(require_helpers.generateId("rs"), {
 		summaryText: reasoning,
@@ -694,21 +966,22 @@ function buildToolCallResponse(toolCalls, model, reasoning, webSearches, overrid
 			query
 		}
 	});
-	for (const tc of toolCalls) output.push({
-		type: "function_call",
-		id: require_helpers.generateId("fc"),
-		call_id: tc.id || require_helpers.generateToolCallId(),
-		name: tc.name,
-		arguments: tc.arguments,
-		status: "completed"
-	});
+	for (const tc of toolCalls) output.push(buildToolCallOutputItem(tc));
 	return buildResponseEnvelope(model, output, overrides);
 }
 function buildContentWithToolCallsStreamEvents(content, toolCalls, model, chunkSize, reasoning, webSearches, overrides, blocks, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	const ordered = legacyOrderedBlocks(blocks);
+	return contentWithToolCallsStreamEvents(content, ordered && ordered.length > 0 ? [] : legacyFunctionCalls(toolCalls), model, chunkSize, reasoning, webSearches, overrides, ordered, emitEncryptedReasoning, synthesizeSummarylessReasoning);
+}
+/**
+* Internal content+tool-calls builder. `ordered` is already resolved (see
+* {@link resolveServedBlockOutcome}); when non-empty it is streamed in array
+* order, otherwise the legacy message-first path runs over `toolCalls`.
+*/
+function contentWithToolCallsStreamEvents(content, toolCalls, model, chunkSize, reasoning, webSearches, overrides, ordered, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
 	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 	const orderedOutputItems = [];
-	if (blocks && blocks.length > 0) {
-		const ordered = require_helpers.resolveFixtureBlocks(blocks);
+	if (ordered && ordered.length > 0) {
 		let outputIndex = nextOutputIndex;
 		for (const block of ordered) {
 			if (block.type === "text") {
@@ -716,25 +989,21 @@ function buildContentWithToolCallsStreamEvents(content, toolCalls, model, chunkS
 				events.push(...msgEvents);
 				orderedOutputItems.push(msgItem);
 			} else {
-				const { events: fcEvents, fcItem } = buildFunctionCallOutputEvents({
-					name: block.name,
-					arguments: block.arguments,
-					id: block.id
-				}, chunkSize, outputIndex);
-				events.push(...fcEvents);
-				orderedOutputItems.push(fcItem);
+				const { events: callEvents, item } = buildToolCallOutputEvents(block, chunkSize, outputIndex);
+				events.push(...callEvents);
+				orderedOutputItems.push(item);
 			}
 			outputIndex += 1;
 		}
 	} else {
+		require_helpers.assertResponsesToolCalls(toolCalls);
 		const { events: msgEvents, msgItem } = buildMessageOutputEvents(content, chunkSize, nextOutputIndex);
 		events.push(...msgEvents);
 		orderedOutputItems.push(msgItem);
 		for (let idx = 0; idx < toolCalls.length; idx++) {
-			const fcOutputIndex = nextOutputIndex + 1 + idx;
-			const { events: fcEvents, fcItem } = buildFunctionCallOutputEvents(toolCalls[idx], chunkSize, fcOutputIndex);
-			events.push(...fcEvents);
-			orderedOutputItems.push(fcItem);
+			const { events: callEvents, item } = buildToolCallOutputEvents(toolCalls[idx], chunkSize, nextOutputIndex + 1 + idx);
+			events.push(...callEvents);
+			orderedOutputItems.push(item);
 		}
 	}
 	events.push({
@@ -751,15 +1020,10 @@ function buildContentWithToolCallsStreamEvents(content, toolCalls, model, chunkS
 	});
 	return events;
 }
-function buildFunctionCallOutputItem(tc) {
-	return {
-		type: "function_call",
-		id: require_helpers.generateId("fc"),
-		call_id: tc.id || require_helpers.generateToolCallId(),
-		name: tc.name,
-		arguments: tc.arguments,
-		status: "completed"
-	};
+/** Non-streaming dispatcher: the completed function or custom tool call item. */
+function buildToolCallOutputItem(tc) {
+	if (isCustomEmittable(tc)) return customToolCallItem(tc, customToolCallItemId(), tc.id || require_helpers.generateToolCallId(), requireFixtureToolInput(tc.input), "completed");
+	return functionCallItem(tc, require_helpers.generateId("fc"), tc.id || require_helpers.generateToolCallId(), requireFixtureToolArguments(tc.arguments), "completed");
 }
 function buildMessageOutputItem(content) {
 	return {
@@ -774,9 +1038,8 @@ function buildMessageOutputItem(content) {
 		}]
 	};
 }
-function buildContentWithToolCallsResponse(content, toolCalls, model, reasoning, webSearches, overrides, blocks, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
-	if (blocks && blocks.length > 0) {
-		const ordered = require_helpers.resolveFixtureBlocks(blocks);
+function buildContentWithToolCallsResponse(content, toolCalls, model, reasoning, webSearches, overrides, ordered, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	if (ordered && ordered.length > 0) {
 		const output = [];
 		if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) output.push(buildReasoningOutputItem(require_helpers.generateId("rs"), {
 			summaryText: reasoning,
@@ -792,15 +1055,12 @@ function buildContentWithToolCallsResponse(content, toolCalls, model, reasoning,
 			}
 		});
 		for (const block of ordered) if (block.type === "text") output.push(buildMessageOutputItem(block.text));
-		else output.push(buildFunctionCallOutputItem({
-			name: block.name,
-			arguments: block.arguments,
-			id: block.id
-		}));
+		else output.push(buildToolCallOutputItem(block));
 		return buildResponseEnvelope(model, output, overrides);
 	}
+	require_helpers.assertResponsesToolCalls(toolCalls);
 	const output = buildOutputPrefix(content, model, reasoning, webSearches, emitEncryptedReasoning, synthesizeSummarylessReasoning);
-	for (const tc of toolCalls) output.push(buildFunctionCallOutputItem(tc));
+	for (const tc of toolCalls) output.push(buildToolCallOutputItem(tc));
 	return buildResponseEnvelope(model, output, overrides);
 }
 async function writeResponsesSSEStream(res, events, optionsOrLatency) {
@@ -869,7 +1129,41 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 		} }));
 		return;
 	}
-	const completionReq = responsesToCompletionRequest(responsesReq);
+	let inputError;
+	if (typeof responsesReq.input !== "string" && !Array.isArray(responsesReq.input)) inputError = "input must be a string or an array";
+	else if (Array.isArray(responsesReq.input)) for (const [index, item] of responsesReq.input.entries()) {
+		if (item === null) {
+			inputError = `input[${index}] must not be null`;
+			break;
+		}
+		if ((item.role === "system" || item.role === "developer" || item.role === "user" || item.role === "assistant") && item.content && typeof item.content !== "string" && !Array.isArray(item.content)) {
+			inputError = `input[${index}].content must be a string or an array`;
+			break;
+		}
+	}
+	const validationError = inputError ?? validateResponsesTools(responsesReq.tools);
+	if (validationError) {
+		journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? "/v1/responses",
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: responsesReq,
+			response: {
+				status: 400,
+				fixture: null
+			}
+		});
+		require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+			message: validationError,
+			type: "invalid_request_error"
+		} }));
+		return;
+	}
+	const extendedTools = defaults.responsesTools === "extended";
+	const completionReq = responsesToCompletionRequest(responsesReq, {
+		extended: extendedTools,
+		logger: defaults.logger
+	});
 	completionReq._endpointType = "chat";
 	completionReq._context = require_helpers.getContext(req);
 	const emitEncryptedReasoning = requestWantsEncryptedReasoning(responsesReq);
@@ -945,27 +1239,116 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 		} }));
 		return;
 	}
-	const response = await require_helpers.resolveResponse(fixture, completionReq);
+	const resolvedResponse = await require_helpers.resolveResponse(fixture, completionReq);
+	const response = extendedTools ? resolvedResponse : require_helpers.withoutLegacyNamespaces(resolvedResponse);
+	const misbehavior = require_misbehavior.planMisbehavior({
+		wire: "openai-responses",
+		fixture,
+		response,
+		request: completionReq,
+		stream: responsesReq.stream === true,
+		emitsToolCallIds: true,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (misbehavior.kind === "error") {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: req.url ?? "/v1/responses",
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: misbehavior.status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		if (!misbehavior.summary?.evaluations.some((evaluation) => evaluation.outcome === "error")) defaults.logger.error(misbehavior.message);
+		require_sse_writer.writeErrorResponse(res, misbehavior.status, JSON.stringify({ error: {
+			message: misbehavior.message,
+			type: "invalid_request_error",
+			code: misbehavior.code
+		} }));
+		return;
+	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const fixtureTimings = fixture.recordedTimings;
 	const effectiveReplaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
-	if (require_helpers.isErrorResponse(response)) {
-		const status = response.status ?? 500;
-		journal.add({
+	if (misbehavior.kind === "applied") {
+		const prepared = prepareResponsesMisbehavior(misbehavior);
+		const output = buildResponsesMisbehavior(prepared, completionReq, chunkSize, emitEncryptedReasoning);
+		const entry = journal.add({
 			method: req.method ?? "POST",
 			path: req.url ?? "/v1/responses",
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: completionReq,
 			response: {
-				status,
+				status: 200,
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry,
+			summary: prepared.summary,
+			defaults,
+			testId
+		});
+		if (responsesReq.stream !== true) {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(output.response));
+		} else {
+			const appliedTimings = prepared.duplicateId && fixtureTimings ? {
+				...fixtureTimings,
+				interChunkDelaysMs: [...fixtureTimings.interChunkDelaysMs]
+			} : fixtureTimings;
+			if (prepared.duplicateId && appliedTimings) {
+				const lastGap = appliedTimings.interChunkDelaysMs.at(-1) ?? 0;
+				while (appliedTimings.interChunkDelaysMs.length < output.events.length - 1) appliedTimings.interChunkDelaysMs.push(lastGap);
+			}
+			const interruption = require_interruption.createInterruptionSignal(fixture);
+			if (!await writeResponsesSSEStream(res, output.events, {
+				latency,
+				streamingProfile: fixture.streamingProfile,
+				recordedTimings: appliedTimings,
+				replaySpeed: effectiveReplaySpeed,
+				signal: interruption?.signal,
+				onChunkSent: interruption?.tick
+			})) {
+				if (!res.writableEnded) res.destroy();
+				entry.response.interrupted = true;
+				entry.response.interruptReason = interruption?.reason();
+			}
+			interruption?.cleanup();
+		}
+		return;
+	}
+	if (require_helpers.isErrorResponse(response)) {
+		const status = response.status ?? 500;
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: req.url ?? "/v1/responses",
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		require_sse_writer.writeErrorResponse(res, status, require_helpers.serializeErrorResponse(response), { retryAfter: response.retryAfter });
 		return;
 	}
-	if (require_helpers.isContentWithToolCallsResponse(response)) {
+	if (require_helpers.isCombinedFixtureResponse(response)) {
 		const overrides = require_helpers.extractOverrides(response);
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, defaults.logger);
@@ -979,12 +1362,21 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const ordered = require_helpers.resolveServedBlockOutcome(response)?.ordered;
+		if (!ordered) require_helpers.assertCustomToolCalls(response);
+		const toolCalls = require_helpers.servedToolCalls(response);
 		if (responsesReq.stream !== true) {
-			const body = buildContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], completionReq.model, effReasoning, response.webSearches, overrides, response.blocks, emitEncryptedReasoning, synthesizeSummarylessReasoning);
+			const body = buildContentWithToolCallsResponse(response.content ?? "", toolCalls, completionReq.model, effReasoning, response.webSearches, overrides, ordered, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildContentWithToolCallsStreamEvents(response.content ?? "", response.toolCalls ?? [], completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, response.blocks, emitEncryptedReasoning, synthesizeSummarylessReasoning);
+			const events = contentWithToolCallsStreamEvents(response.content ?? "", toolCalls, completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, ordered, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeResponsesSSEStream(res, events, {
 				latency,
@@ -1016,6 +1408,12 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		if (responsesReq.stream !== true) {
 			const body = buildTextResponse(response.content, completionReq.model, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
@@ -1053,12 +1451,19 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		require_helpers.assertCustomToolCalls(response);
 		if (responsesReq.stream !== true) {
-			const body = buildToolCallResponse(response.toolCalls, completionReq.model, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
+			const body = buildToolCallResponse(require_helpers.servedToolCalls(response), completionReq.model, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildToolCallStreamEvents(response.toolCalls, completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
+			const events = toolCallStreamEvents(require_helpers.servedToolCalls(response), completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeResponsesSSEStream(res, events, {
 				latency,
@@ -1076,29 +1481,159 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 		}
 		return;
 	}
-	journal.add({
-		method: req.method ?? "POST",
-		path: req.url ?? "/v1/responses",
-		headers: require_helpers.flattenHeaders(req.headers),
-		body: completionReq,
-		response: {
-			status: 500,
-			fixture
-		}
+	require_misbehavior.recordMisbehaviorOutcome({
+		entry: journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? "/v1/responses",
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: completionReq,
+			response: {
+				status: 500,
+				fixture
+			}
+		}),
+		summary: misbehavior.summary,
+		defaults,
+		testId
 	});
 	require_sse_writer.writeErrorResponse(res, 500, JSON.stringify({ error: {
 		message: "Fixture response did not match any known type",
 		type: "server_error"
 	} }));
 }
+/** Prepare call IDs once, retaining the engine's effective blocks and exact served-call metadata. */
+function prepareResponsesMisbehavior(plan) {
+	return require_helpers.prepareOpenAIChatMisbehavior(plan);
+}
+/** Build one faulted payload/event sequence for both HTTP and Responses WebSocket consumers. */
+function buildResponsesMisbehavior(plan, request, chunkSize, emitEncryptedReasoning = false) {
+	const response = plan.response;
+	if (!(require_helpers.isCombinedFixtureResponse(response) || require_helpers.isTextResponse(response) || require_helpers.isToolCallResponse(response))) throw new Error("Responses misbehavior requires a prepared chat response");
+	const overrides = require_helpers.extractOverrides(response);
+	const reasoning = plan.reasoning ?? ("reasoning" in response ? response.reasoning : void 0);
+	const webSearches = "webSearches" in response ? response.webSearches : void 0;
+	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(request.model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, false, plan.reasoning !== void 0);
+	const output = [...prefixOutputItems];
+	let outputIndex = nextOutputIndex;
+	const incomplete = plan.stop === "length" || plan.stop === "content_filter";
+	if (plan.refusal !== void 0) {
+		const id = itemId();
+		const part = {
+			type: "refusal",
+			refusal: plan.refusal
+		};
+		const item = {
+			id,
+			type: "message",
+			role: "assistant",
+			status: "completed",
+			content: [part]
+		};
+		const position = {
+			item_id: id,
+			output_index: outputIndex,
+			content_index: 0
+		};
+		events.push({
+			type: "response.output_item.added",
+			output_index: outputIndex,
+			item: {
+				...item,
+				status: "in_progress",
+				content: []
+			}
+		}, {
+			type: "response.content_part.added",
+			...position,
+			part: {
+				type: "refusal",
+				refusal: ""
+			}
+		});
+		for (let i = 0; i < plan.refusal.length; i += chunkSize) events.push({
+			type: "response.refusal.delta",
+			...position,
+			delta: plan.refusal.slice(i, i + chunkSize)
+		});
+		events.push({
+			type: "response.refusal.done",
+			...position,
+			refusal: plan.refusal
+		}, {
+			type: "response.content_part.done",
+			...position,
+			part
+		}, {
+			type: "response.output_item.done",
+			output_index: outputIndex,
+			item
+		});
+		output.push(item);
+	} else if (plan.summary.fault !== "empty-response" && plan.stop !== "content_filter" && plan.reasoning === void 0) {
+		const combined = require_helpers.isCombinedFixtureResponse(response);
+		const blocks = (combined ? require_helpers.resolveServedBlockOutcome(response) : void 0)?.ordered ?? [..."content" in response && typeof response.content === "string" ? [{
+			type: "text",
+			text: response.content
+		}] : [], ...combined || require_helpers.isToolCallResponse(response) ? require_helpers.servedToolCalls(response).map(require_helpers.toolCallFixtureBlock) : []];
+		let callIndex = 0;
+		for (const block of blocks) {
+			if (block.type === "text") {
+				const message = buildMessageOutputEvents(block.text, chunkSize, outputIndex);
+				events.push(...message.events);
+				output.push(message.msgItem);
+			} else {
+				const call = block.type === "customToolCall" ? buildCustomToolCallOutputEvents(block, chunkSize, outputIndex) : buildFunctionCallOutputEvents(block, chunkSize, outputIndex);
+				const cut = plan.summary.fault === "stop-length-mid-tool" && callIndex === plan.target?.index;
+				const item = cut ? {
+					...call.item,
+					status: "incomplete"
+				} : call.item;
+				events.push(...call.events.map((event) => cut && event.type === "response.output_item.done" ? {
+					...event,
+					item
+				} : event));
+				output.push(item);
+				callIndex++;
+			}
+			outputIndex++;
+		}
+	}
+	const usage = require_helpers.resolveOpenAIChatMisbehaviorUsage(plan, request);
+	const body = {
+		id: respId,
+		object: "response",
+		created_at: created,
+		model: overrides?.model ?? request.model,
+		status: incomplete ? "incomplete" : responsesStatus(overrides?.finishReason, "completed"),
+		...incomplete ? { incomplete_details: { reason: plan.stop === "content_filter" ? "content_filter" : "max_output_tokens" } } : {},
+		output,
+		usage: {
+			input_tokens: usage.prompt_tokens,
+			output_tokens: usage.completion_tokens,
+			total_tokens: usage.total_tokens
+		}
+	};
+	events.push({
+		type: incomplete ? "response.incomplete" : "response.completed",
+		response: body
+	});
+	return {
+		response: body,
+		events
+	};
+}
 
 //#endregion
 exports.buildContentWithToolCallsStreamEvents = buildContentWithToolCallsStreamEvents;
+exports.buildResponsesMisbehavior = buildResponsesMisbehavior;
 exports.buildTextResponse = buildTextResponse;
 exports.buildTextStreamEvents = buildTextStreamEvents;
 exports.buildToolCallStreamEvents = buildToolCallStreamEvents;
+exports.contentWithToolCallsStreamEvents = contentWithToolCallsStreamEvents;
 exports.handleResponses = handleResponses;
+exports.prepareResponsesMisbehavior = prepareResponsesMisbehavior;
 exports.requestIncludesEncryptedReasoning = requestIncludesEncryptedReasoning;
 exports.requestWantsEncryptedReasoning = requestWantsEncryptedReasoning;
 exports.responsesToCompletionRequest = responsesToCompletionRequest;
+exports.toolCallStreamEvents = toolCallStreamEvents;
 //# sourceMappingURL=responses.cjs.map