@copilotkit/aimock 1.45.1 → 1.47.0

package/dist/gemini.cjs

@@ -1,13 +1,28 @@
+const require_errors = require('./response/errors.cjs');
+const require_policy = require('./response/policy.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');
+const require_logger = require('./logger.cjs');
+const require_timing = require('./response/timing.cjs');
+const require_deliver = require('./response/deliver.cjs');
+const require_proxy = require('./response/proxy.cjs');
+const require_raw = require('./response/raw.cjs');
+const require_finish = require('./response/finish.cjs');
+const require_gemini = require('./response/usage/codecs/gemini.cjs');
 
 //#region src/gemini.ts
 /**
+* Google Gemini GenerateContent API support.
+*
+* Translates incoming Gemini requests into the ChatCompletionRequest format
+* used by the fixture router, and converts fixture responses back into the
+* Gemini GenerateContent streaming (or non-streaming) format.
+*/
+/**
 * Validate the shape of a Gemini `generateContent` body.
 *
 * Returns an error detail string when the shape is wrong, or null when
@@ -133,26 +148,115 @@ function geminiToCompletionRequest(req, model, stream) {
 }
 function geminiFinishReason(finishReason, defaultReason) {
 	if (!finishReason) return defaultReason;
-	if (finishReason === "stop") return "STOP";
-	if (finishReason === "tool_calls") return "FUNCTION_CALL";
-	if (finishReason === "length") return "MAX_TOKENS";
-	if (finishReason === "content_filter") return "SAFETY";
-	return finishReason;
+	return require_finish.mapGeminiFinish(finishReason);
 }
 function geminiUsageMetadata(overrides) {
-	if (!overrides?.usage) return {
-		promptTokenCount: 0,
-		candidatesTokenCount: 0,
-		totalTokenCount: 0
+	return require_gemini.render(overrides);
+}
+function geminiWholeTextPart(text, partIndex) {
+	return [{
+		partIndex,
+		start: 0,
+		end: text.length
+	}];
+}
+function geminiGroundingSupports(text, citations, textParts) {
+	const segment = (part, from, to) => {
+		const partText = text.slice(part.start, part.end);
+		const start = Math.min(Math.max(from - part.start, 0), partText.length);
+		const end = Math.min(Math.max(to - part.start, start), partText.length);
+		const byteOffset = (charIndex) => Buffer.byteLength(partText.slice(0, charIndex), "utf8");
+		return {
+			partIndex: part.partIndex,
+			startIndex: byteOffset(start),
+			endIndex: byteOffset(end),
+			text: partText.slice(start, end)
+		};
 	};
-	const prompt = overrides.usage.promptTokenCount ?? overrides.usage.prompt_tokens ?? overrides.usage.input_tokens ?? 0;
-	const candidates = overrides.usage.candidatesTokenCount ?? overrides.usage.completion_tokens ?? overrides.usage.output_tokens ?? 0;
+	return citations.flatMap((c, i) => {
+		const spanned = textParts.filter((p) => Math.max(c.startIndex, p.start) < Math.min(c.endIndex, p.end));
+		return (spanned.length > 0 ? spanned : [textParts.find((p) => c.startIndex < p.end) ?? textParts[textParts.length - 1]]).map((p) => ({
+			segment: segment(p, c.startIndex, c.endIndex),
+			groundingChunkIndices: [i]
+		}));
+	});
+}
+function geminiGroundingMetadata(text, overrides, textParts) {
+	const citations = require_helpers.resolveCitations(text, overrides?.citations);
+	if (citations.length === 0 || textParts.length === 0) return void 0;
 	return {
-		promptTokenCount: prompt,
-		candidatesTokenCount: candidates,
-		totalTokenCount: overrides.usage.totalTokenCount ?? prompt + candidates
+		groundingChunks: geminiGroundingChunks(citations),
+		groundingSupports: geminiGroundingSupports(text, citations, textParts)
 	};
 }
+function geminiGroundingChunks(citations) {
+	return citations.map((c) => ({ web: {
+		uri: c.url,
+		title: c.title
+	} }));
+}
+function geminiGroundingField(text, overrides, textParts) {
+	const groundingMetadata = geminiGroundingMetadata(text, overrides, textParts);
+	return groundingMetadata ? { groundingMetadata } : {};
+}
+function geminiStreamGroundingFields(text, overrides, spans) {
+	const fields = spans.map(() => ({}));
+	const citations = require_helpers.resolveCitations(text, overrides?.citations);
+	if (citations.length === 0 || spans.length === 0) return fields;
+	const textParts = spans.map((s, k) => ({
+		partIndex: k,
+		start: s.start,
+		end: s.end
+	}));
+	const groundingChunks = geminiGroundingChunks(citations);
+	for (const support of geminiGroundingSupports(text, citations, textParts)) {
+		const k = support.segment.partIndex;
+		(fields[k].groundingMetadata ??= {
+			groundingChunks,
+			groundingSupports: []
+		}).groundingSupports.push({
+			...support,
+			segment: {
+				...support.segment,
+				partIndex: 0
+			}
+		});
+	}
+	return fields;
+}
+function geminiTextChunkSpans(text, chunkSize, offset = 0) {
+	if (text.length === 0) return [{
+		start: offset,
+		end: offset
+	}];
+	const spans = [];
+	let start = offset;
+	for (const slice of require_helpers.surrogateSafeChunks(text, chunkSize)) {
+		spans.push({
+			start,
+			end: start + slice.length
+		});
+		start += slice.length;
+	}
+	return spans;
+}
+function geminiFileParts(overrides) {
+	return require_helpers.fixtureFiles(overrides?.files).map((f) => ({ inlineData: {
+		mimeType: f.mimeType,
+		data: f.data
+	} }));
+}
+function geminiFileChunks(overrides) {
+	const parts = geminiFileParts(overrides);
+	if (parts.length === 0) return [];
+	return [{ candidates: [{
+		content: {
+			role: "model",
+			parts
+		},
+		index: 0
+	}] }];
+}
 function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 	const chunks = [];
 	const effectiveFinish = geminiFinishReason(overrides?.finishReason, "STOP");
@@ -170,9 +274,11 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 			index: 0
 		}] });
 	}
-	for (let i = 0; i < content.length; i += chunkSize) {
-		const slice = content.slice(i, i + chunkSize);
-		const isLast = i + chunkSize >= content.length;
+	chunks.push(...geminiFileChunks(overrides));
+	const grounding = geminiStreamGroundingFields(content, overrides, geminiTextChunkSpans(content, chunkSize));
+	const contentSlices = require_helpers.surrogateSafeChunks(content, chunkSize);
+	contentSlices.forEach((slice, k) => {
+		const isLast = k === contentSlices.length - 1;
 		const chunk = {
 			candidates: [{
 				content: {
@@ -180,12 +286,13 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 					parts: [{ text: slice }]
 				},
 				index: 0,
-				...isLast ? { finishReason: effectiveFinish } : {}
+				...isLast ? { finishReason: effectiveFinish } : {},
+				...grounding[k]
 			}],
 			...isLast ? { usageMetadata: usage } : {}
 		};
 		chunks.push(chunk);
-	}
+	});
 	if (content.length === 0) chunks.push({
 		candidates: [{
 			content: {
@@ -193,6 +300,7 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 				parts: [{ text: "" }]
 			},
 			finishReason: effectiveFinish,
+			...grounding[0],
 			index: 0
 		}],
 		usageMetadata: usage
@@ -223,6 +331,8 @@ function buildGeminiToolCallStreamChunks(toolCalls, chunkSize, logger, reasoning
 			index: 0
 		}] });
 	}
+	chunks.push(...geminiFileChunks(overrides));
+	require_helpers.resolveCitations("", overrides?.citations);
 	const parts = toolCalls.map((tc) => parseToolCallPart(tc, logger));
 	chunks.push({
 		candidates: [{
@@ -243,6 +353,8 @@ function buildGeminiTextResponse(content, reasoning, overrides) {
 		text: reasoning,
 		thought: true
 	});
+	parts.push(...geminiFileParts(overrides));
+	const textParts = geminiWholeTextPart(content, parts.length);
 	parts.push({ text: content });
 	return {
 		candidates: [{
@@ -251,17 +363,20 @@ function buildGeminiTextResponse(content, reasoning, overrides) {
 				parts
 			},
 			finishReason: geminiFinishReason(overrides?.finishReason, "STOP"),
+			...geminiGroundingField(content, overrides, textParts),
 			index: 0
 		}],
 		usageMetadata: geminiUsageMetadata(overrides)
 	};
 }
 function buildGeminiToolCallResponse(toolCalls, logger, reasoning, overrides) {
+	require_helpers.resolveCitations("", overrides?.citations);
 	const parts = [];
 	if (reasoning) parts.push({
 		text: reasoning,
 		thought: true
 	});
+	parts.push(...geminiFileParts(overrides));
 	parts.push(...toolCalls.map((tc) => parseToolCallPart(tc, logger)));
 	return {
 		candidates: [{
@@ -290,9 +405,19 @@ function buildGeminiContentWithToolCallsStreamChunks(content, toolCalls, chunkSi
 			index: 0
 		}] });
 	}
+	chunks.push(...geminiFileChunks(overrides));
 	if (blocks && blocks.length > 0) {
 		const outcome = require_helpers.resolveFixtureBlockOutcome(blocks);
 		const resolved = outcome.ordered;
+		const spans = [];
+		let offset = 0;
+		for (const block of resolved) {
+			if (block.type !== "text") continue;
+			spans.push(...geminiTextChunkSpans(block.text, chunkSize, offset));
+			offset += block.text.length;
+		}
+		const grounding = geminiStreamGroundingFields(outcome.content, overrides, spans);
+		let textChunk = 0;
 		resolved.forEach((block, i) => {
 			const isLast = i === resolved.length - 1;
 			const finishReason = isLast ? geminiFinishReason(overrides?.finishReason, outcome.hasToolCalls ? "FUNCTION_CALL" : "STOP") : void 0;
@@ -322,47 +447,53 @@ function buildGeminiContentWithToolCallsStreamChunks(content, toolCalls, chunkSi
 							parts: [{ text: "" }]
 						},
 						...finishReason ? { finishReason } : {},
+						...grounding[textChunk++],
 						index: 0
 					}],
 					...isLast ? { usageMetadata: geminiUsageMetadata(overrides) } : {}
 				});
-				else for (let j = 0; j < text.length; j += chunkSize) {
-					const slice = text.slice(j, j + chunkSize);
-					const lastSlice = j + chunkSize >= text.length;
-					const sliceFinish = isLast && lastSlice ? finishReason : void 0;
-					chunks.push({
-						candidates: [{
-							content: {
-								role: "model",
-								parts: [{ text: slice }]
-							},
-							...sliceFinish ? { finishReason: sliceFinish } : {},
-							index: 0
-						}],
-						...isLast && lastSlice ? { usageMetadata: geminiUsageMetadata(overrides) } : {}
+				else {
+					const slices = require_helpers.surrogateSafeChunks(text, chunkSize);
+					slices.forEach((slice, j) => {
+						const lastSlice = j === slices.length - 1;
+						const sliceFinish = isLast && lastSlice ? finishReason : void 0;
+						chunks.push({
+							candidates: [{
+								content: {
+									role: "model",
+									parts: [{ text: slice }]
+								},
+								...sliceFinish ? { finishReason: sliceFinish } : {},
+								...grounding[textChunk++],
+								index: 0
+							}],
+							...isLast && lastSlice ? { usageMetadata: geminiUsageMetadata(overrides) } : {}
+						});
 					});
 				}
 			}
 		});
 		return chunks;
 	}
+	const grounding = geminiStreamGroundingFields(content, overrides, geminiTextChunkSpans(content, chunkSize));
 	if (content.length === 0) chunks.push({ candidates: [{
 		content: {
 			role: "model",
 			parts: [{ text: "" }]
 		},
+		...grounding[0],
 		index: 0
 	}] });
-	else for (let i = 0; i < content.length; i += chunkSize) {
-		const slice = content.slice(i, i + chunkSize);
+	else require_helpers.surrogateSafeChunks(content, chunkSize).forEach((slice, k) => {
 		chunks.push({ candidates: [{
 			content: {
 				role: "model",
 				parts: [{ text: slice }]
 			},
+			...grounding[k],
 			index: 0
 		}] });
-	}
+	});
 	const parts = toolCalls.map((tc) => parseToolCallPart(tc, logger));
 	chunks.push({
 		candidates: [{
@@ -383,18 +514,31 @@ function buildGeminiContentWithToolCallsResponse(content, toolCalls, logger, rea
 		text: reasoning,
 		thought: true
 	});
+	parts.push(...geminiFileParts(overrides));
 	let blockHasTools;
+	let groundingText = content;
+	const textParts = [];
 	if (blocks && blocks.length > 0) {
 		const outcome = require_helpers.resolveFixtureBlockOutcome(blocks);
 		const resolved = outcome.ordered;
 		blockHasTools = outcome.hasToolCalls;
+		groundingText = outcome.content;
 		for (const block of resolved) if (block.type === "toolCall") parts.push(parseToolCallPart({
 			name: block.name,
 			arguments: block.arguments,
 			id: block.id
 		}, logger));
-		else parts.push({ text: block.text });
+		else {
+			const start = textParts.length > 0 ? textParts[textParts.length - 1].end : 0;
+			textParts.push({
+				partIndex: parts.length,
+				start,
+				end: start + block.text.length
+			});
+			parts.push({ text: block.text });
+		}
 	} else {
+		textParts.push(...geminiWholeTextPart(content, parts.length));
 		parts.push({ text: content });
 		parts.push(...toolCalls.map((tc) => parseToolCallPart(tc, logger)));
 	}
@@ -405,6 +549,7 @@ function buildGeminiContentWithToolCallsResponse(content, toolCalls, logger, rea
 				parts
 			},
 			finishReason: geminiFinishReason(overrides?.finishReason, blockHasTools === false ? "STOP" : "FUNCTION_CALL"),
+			...geminiGroundingField(groundingText, overrides, textParts),
 			index: 0
 		}],
 		usageMetadata: geminiUsageMetadata(overrides)
@@ -440,11 +585,7 @@ function buildGeminiAudioResponse(audio, toolCalls, logger, effReasoning) {
 			finishReason: toolCalls.length ? "FUNCTION_CALL" : "STOP",
 			index: 0
 		}],
-		usageMetadata: {
-			promptTokenCount: 0,
-			candidatesTokenCount: 0,
-			totalTokenCount: 0
-		}
+		usageMetadata: require_gemini.render()
 	};
 }
 function buildGeminiAudioStreamChunks(audio, toolCalls, logger, effReasoning) {
@@ -457,37 +598,22 @@ function buildGeminiAudioStreamChunks(audio, toolCalls, logger, effReasoning) {
 			finishReason: toolCalls.length ? "FUNCTION_CALL" : "STOP",
 			index: 0
 		}],
-		usageMetadata: {
-			promptTokenCount: 0,
-			candidatesTokenCount: 0,
-			totalTokenCount: 0
-		}
+		usageMetadata: require_gemini.render()
 	}];
 }
-async function writeGeminiSSEStream(res, chunks, optionsOrLatency) {
-	const opts = typeof optionsOrLatency === "number" ? { latency: optionsOrLatency } : optionsOrLatency ?? {};
-	const latency = opts.latency ?? 0;
-	const profile = opts.streamingProfile;
-	const { recordedTimings, replaySpeed } = opts;
-	const signal = opts.signal;
-	const onChunkSent = opts.onChunkSent;
-	if (res.writableEnded) return true;
-	res.setHeader("Content-Type", "text/event-stream");
-	res.setHeader("Cache-Control", "no-cache");
-	res.setHeader("Connection", "keep-alive");
-	let chunkIndex = 0;
-	for (const chunk of chunks) {
-		const chunkDelay = require_sse_writer.calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);
-		if (chunkDelay > 0) await require_sse_writer.delay(chunkDelay, signal);
-		if (signal?.aborted) return false;
-		if (res.writableEnded) return true;
-		res.write(`data: ${JSON.stringify(chunk)}\n\n`);
-		onChunkSent?.();
-		if (signal?.aborted) return false;
-		chunkIndex++;
-	}
-	if (!res.writableEnded) res.end();
-	return true;
+const GEMINI_SSE = require_sse_writer.sseCodec({ done: false });
+const SILENT_LOGGER = new require_logger.Logger("silent");
+/**
+* The reasoning a misbehavior reply's non-streaming wait is sized with: the
+* plan response's reasoning through the same model and strict gate the
+* builders apply. The gate runs with a silent logger, so the builder's own
+* warning stays the only one. A reasoning-only plan carries its reasoning on
+* the plan, and `misbehaviorPayloadLength` reads it there.
+*/
+function misbehaviorPayloadReasoning(plan, model, strict) {
+	const response = plan.response;
+	if (plan.reasoning !== void 0 || !(require_helpers.isCombinedFixtureResponse(response) || require_helpers.isTextResponse(response) || require_helpers.isToolCallResponse(response))) return;
+	return require_helpers.resolveReasoningForModel(response.reasoning, model, strict, SILENT_LOGGER);
 }
 /** Prepare native fault output once; the journal describes these exact parts. */
 function prepareGeminiMisbehavior(plan, request, streaming, chunkSize, logger, strict) {
@@ -520,7 +646,11 @@ function prepareGeminiMisbehavior(plan, request, streaming, chunkSize, logger, s
 		candidate.finishReason = "UNEXPECTED_TOOL_CALL";
 		chunks = [{ candidates: [candidate] }];
 	} else if (fault === "stop-length-mid-tool") {
-		candidate.content.parts = content ? [{ text: content }] : [];
+		const parts = geminiFileParts(overrides);
+		const textPartIndex = parts.length;
+		if (content) parts.push({ text: content });
+		candidate.content.parts = parts;
+		if (content) Object.assign(candidate, geminiGroundingField(content, overrides, geminiWholeTextPart(content, textPartIndex)));
 		candidate.finishReason = "MAX_TOKENS";
 		chunks = [{ candidates: [candidate] }];
 	} else if (fault === "empty-response") {
@@ -555,13 +685,14 @@ function prepareGeminiMisbehavior(plan, request, streaming, chunkSize, logger, s
 		arguments: JSON.stringify(part.functionCall.args),
 		...part.functionCall.id ? { id: part.functionCall.id } : {}
 	}] : []);
-	const usage = require_helpers.resolveUsage(void 0, request.messages.map((message) => typeof message.content === "string" ? message.content : (message.content ?? []).map((part) => part.text ?? "").join("")).join(""), parts.map((part) => part.text ?? (part.functionCall ? part.functionCall.name + JSON.stringify(part.functionCall.args) : "")).join(""));
+	const prompt = request.messages.map((message) => typeof message.content === "string" ? message.content : (message.content ?? []).map((part) => part.text ?? "").join("")).join("");
+	const output = parts.map((part) => part.text ?? (part.functionCall ? part.functionCall.name + JSON.stringify(part.functionCall.args) : "")).join("");
 	for (const chunk of chunks) delete chunk.usageMetadata;
-	chunks[chunks.length - 1].usageMetadata = {
-		promptTokenCount: usage.prompt_tokens,
-		candidatesTokenCount: usage.completion_tokens,
-		totalTokenCount: usage.total_tokens
-	};
+	chunks[chunks.length - 1].usageMetadata = require_gemini.render(void 0, {
+		kind: "applied-misbehavior",
+		promptText: prompt,
+		completionText: output
+	});
 	return {
 		chunks,
 		summary: {
@@ -589,11 +720,11 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture: null
 			}
 		});
-		require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+		require_sse_writer.writeErrorResponse(res, 400, require_errors.renderError("gemini", "validation", {
 			message: `Malformed JSON body: ${detail}`,
-			code: 400,
+			bodyCode: 400,
 			status: "INVALID_ARGUMENT"
-		} }));
+		}).body);
 		return;
 	}
 	if (!require_helpers.isJsonObject(geminiReq)) {
@@ -607,11 +738,11 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture: null
 			}
 		});
-		require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+		require_sse_writer.writeErrorResponse(res, 400, require_errors.renderError("gemini", "validation", {
 			message: "Request body must be a JSON object",
-			code: 400,
+			bodyCode: 400,
 			status: "INVALID_ARGUMENT"
-		} }));
+		}).body);
 		return;
 	}
 	const geminiShapeError = validateGeminiBody(geminiReq);
@@ -626,18 +757,21 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture: null
 			}
 		});
-		require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+		require_sse_writer.writeErrorResponse(res, 400, require_errors.renderError("gemini", "validation", {
 			message: `Invalid argument: ${geminiShapeError}`,
-			code: 400,
+			bodyCode: 400,
 			status: "INVALID_ARGUMENT"
-		} }));
+		}).body);
 		return;
 	}
 	const completionReq = geminiToCompletionRequest(geminiReq, model, streaming);
 	completionReq._endpointType = "chat";
 	completionReq._context = require_helpers.getContext(req);
 	const testId = require_helpers.getTestId(req);
-	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, require_router.recordMatchOptions(!!defaults.record, defaults.logger));
+	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, {
+		...require_router.recordMatchOptions(!!defaults.record, defaults.logger),
+		wire: "gemini"
+	});
 	const path = req.url ?? `/v1beta/models/${model}:generateContent`;
 	if (fixture) logger.debug(`Fixture matched: ${JSON.stringify(fixture.match).slice(0, 120)}`);
 	else logger.debug(`No fixture matched for request`);
@@ -649,7 +783,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 		body: completionReq
 	}, fixture ? "fixture" : "proxy", defaults.registry, defaults.logger)) return;
 	if (!fixture) {
-		if (require_helpers.resolveStrictMode(defaults.strict, req.headers)) {
+		const decisions = require_policy.resolveRequestDecisions(defaults.strict, req.headers);
+		if (decisions.fixtureMiss) {
 			const strictMessage = require_helpers.strictNoMatchMessage(skippedBySequenceOrTurn);
 			logger.error(require_helpers.strictNoMatchLogLine(req.method ?? "POST", path, skippedBySequenceOrTurn));
 			journal.add({
@@ -660,18 +795,18 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				response: {
 					status: 503,
 					fixture: null,
-					...require_helpers.strictOverrideField(defaults.strict, req.headers)
+					...require_policy.strictOverrideField(defaults.strict, req.headers)
 				}
 			});
-			require_sse_writer.writeErrorResponse(res, 503, JSON.stringify({ error: {
+			require_sse_writer.writeErrorResponse(res, 503, require_errors.renderError("gemini", "strict-miss", {
 				message: strictMessage,
-				code: 503,
+				bodyCode: 503,
 				status: "UNAVAILABLE"
-			} }));
+			}).body);
 			return;
 		}
-		if (defaults.record) {
-			const outcome = await require_recorder.proxyAndRecord(req, res, completionReq, providerKey, path, fixtures, defaults, raw);
+		if (decisions.upstream && defaults.record) {
+			const { outcome, clientHungUp } = await require_proxy.withHangUpDetection(req, res, () => require_recorder.proxyAndRecord(req, res, completionReq, providerKey, path, fixtures, defaults, raw));
 			if (outcome === "handled_by_hook") return;
 			if (outcome !== "not_configured") {
 				journal.add({
@@ -682,7 +817,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 					response: {
 						status: res.statusCode ?? 200,
 						fixture: null,
-						source: "proxy"
+						source: "proxy",
+						...require_proxy.proxyInterruption(res, clientHungUp)
 					}
 				});
 				return;
@@ -696,14 +832,14 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			response: {
 				status: 404,
 				fixture: null,
-				...require_helpers.strictOverrideField(defaults.strict, req.headers)
+				...require_policy.strictOverrideField(defaults.strict, req.headers)
 			}
 		});
-		require_sse_writer.writeErrorResponse(res, 404, JSON.stringify({ error: {
+		require_sse_writer.writeErrorResponse(res, 404, require_errors.renderError("gemini", "fixture-miss", {
 			message: "No fixture matched",
-			code: 404,
+			bodyCode: 404,
 			status: "NOT_FOUND"
-		} }));
+		}).body);
 		return;
 	}
 	const response = await require_helpers.resolveResponse(fixture, completionReq);
@@ -736,18 +872,31 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		if (misbehavior.summary?.evaluations.length === 0) logger.error(`${req.method ?? "POST"} ${path}: ${misbehavior.message}`);
-		require_sse_writer.writeErrorResponse(res, misbehavior.status, JSON.stringify({ error: {
-			code: misbehavior.status,
+		require_sse_writer.writeErrorResponse(res, misbehavior.status, require_errors.renderError("gemini", "misbehavior", {
+			bodyCode: misbehavior.status,
 			message: misbehavior.message,
 			status: misbehavior.status === 400 ? "INVALID_ARGUMENT" : "UNIMPLEMENTED"
-		} }));
+		}).body);
 		return;
 	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
+	const streamTiming = {
+		latency,
+		streamingProfile: fixture.streamingProfile,
+		recordedTimings: fixture.recordedTimings,
+		replaySpeed
+	};
+	const jsonOpts = (payloadLength, duplicateId = false) => ({
+		surface: "other",
+		payloadLength,
+		chunkSize,
+		recordedTimings: fixture.recordedTimings,
+		duplicateId,
+		replaySpeed
+	});
 	if (misbehavior.kind === "applied") {
-		const prepared = prepareGeminiMisbehavior(misbehavior, completionReq, streaming, chunkSize, logger, require_helpers.resolveStrictMode(defaults.strict, req.headers));
 		const entry = journal.add({
 			method: req.method ?? "POST",
 			path,
@@ -758,6 +907,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture
 			}
 		});
+		const strictReasoning = require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
+		const prepared = prepareGeminiMisbehavior(misbehavior, completionReq, streaming, chunkSize, logger, strictReasoning);
 		require_misbehavior.recordMisbehaviorOutcome({
 			entry,
 			summary: prepared.summary,
@@ -765,24 +916,26 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		if (!streaming) {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(prepared.chunks[0]));
-		} else {
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, prepared.chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				entry.response.interrupted = true;
-				entry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+			const preparedBody = prepared.chunks[0];
+			await require_deliver.deliverJson(res, entry, fixture, () => preparedBody, jsonOpts(require_timing.misbehaviorPayloadLength(misbehavior, misbehaviorPayloadReasoning(misbehavior, completionReq.model, strictReasoning)), !!misbehavior.duplicateId));
+		} else await require_deliver.deliverStream(res, entry, fixture, GEMINI_SSE, prepared.chunks, streamTiming);
+		return;
+	}
+	if (require_helpers.isRawResponse(response)) {
+		await require_raw.serveRawResponse({
+			wire: "gemini",
+			stream: streaming,
+			req,
+			res,
+			fixture,
+			response,
+			body: completionReq,
+			journal,
+			defaults,
+			testId,
+			misbehaviorSummary: misbehavior.summary,
+			errorWire: "gemini"
+		});
 		return;
 	}
 	if (require_helpers.isErrorResponse(response)) {
@@ -802,16 +955,15 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			defaults,
 			testId
 		});
-		const geminiError = { error: {
-			code: status,
+		require_sse_writer.writeErrorResponse(res, status, require_errors.renderError("gemini", "fixture", {
+			bodyCode: status,
 			message: response.error.message,
 			status: response.error.type ?? "ERROR"
-		} };
-		require_sse_writer.writeErrorResponse(res, status, JSON.stringify(geminiError), { retryAfter: response.retryAfter });
+		}).body, { retryAfter: response.retryAfter });
 		return;
 	}
 	if (require_helpers.isAudioResponse(response)) {
-		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
@@ -830,33 +982,14 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		const audioToolCalls = Array.isArray(response.toolCalls) ? require_helpers.requireServedFunctionToolCalls(response, wire) : [];
-		if (!streaming) {
-			const body = buildGeminiAudioResponse(response, audioToolCalls, logger, effReasoning);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiAudioStreamChunks(response, audioToolCalls, logger, effReasoning);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiAudioResponse(response, audioToolCalls, logger, effReasoning), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiAudioStreamChunks(response, audioToolCalls, logger, effReasoning), streamTiming);
 		return;
 	}
 	if (require_helpers.isCombinedFixtureResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
-		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
@@ -875,33 +1008,14 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, wire);
-		if (!streaming) {
-			const body = buildGeminiContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiContentWithToolCallsStreamChunks(response.content ?? "", functionToolCalls, chunkSize, logger, effReasoning, overrides, response.blocks);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiContentWithToolCallsStreamChunks(response.content ?? "", functionToolCalls, chunkSize, logger, effReasoning, overrides, response.blocks), streamTiming);
 		return;
 	}
 	if (require_helpers.isTextResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
-		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
@@ -919,33 +1033,14 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			defaults,
 			testId
 		});
-		if (!streaming) {
-			const body = buildGeminiTextResponse(response.content, effReasoning, overrides);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiTextStreamChunks(response.content, chunkSize, effReasoning, overrides);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiTextResponse(response.content, effReasoning, overrides), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiTextStreamChunks(response.content, chunkSize, effReasoning, overrides), streamTiming);
 		return;
 	}
 	if (require_helpers.isToolCallResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
-		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
@@ -964,27 +1059,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, wire);
-		if (!streaming) {
-			const body = buildGeminiToolCallResponse(functionToolCalls, logger, effReasoning, overrides);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiToolCallStreamChunks(functionToolCalls, chunkSize, logger, effReasoning, overrides);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiToolCallResponse(functionToolCalls, logger, effReasoning, overrides), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiToolCallStreamChunks(functionToolCalls, chunkSize, logger, effReasoning, overrides), streamTiming);
 		return;
 	}
 	require_misbehavior.recordMisbehaviorOutcome({
@@ -1002,13 +1078,14 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 		defaults,
 		testId
 	});
-	require_sse_writer.writeErrorResponse(res, 500, JSON.stringify({ error: {
+	require_sse_writer.writeErrorResponse(res, 500, require_errors.renderError("gemini", "unknown-response", {
 		message: "Fixture response did not match any known type",
-		code: 500,
+		bodyCode: 500,
 		status: "INTERNAL"
-	} }));
+	}).body);
 }
 
 //#endregion
+exports.geminiToCompletionRequest = geminiToCompletionRequest;
 exports.handleGemini = handleGemini;
 //# sourceMappingURL=gemini.cjs.map